/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using FilterBackpropWindow5Stride2 = WindowStrideTest<Pair, 5, 2>;
TYPED_TEST_SUITE(FilterBackpropWindow5Stride2, GTestTypeTriples);
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2031., 2130., 2746., 1968., 2058., 2724., 2823., 3628., 2598.,
      2688., 3448., 3556., 4560., 3256., 3352., 1860., 1923., 2428.,
      1698., 1752., 2301., 2364., 2974., 2076., 2130.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120., 130., 140., 150., 160., 190., 200., 210., 220.,
      230., 260., 270., 280., 290., 300., 330., 340., 350.,
      360., 370., 400., 410., 420., 430., 440.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3909., 4062., 4098., 4260., 5276., 5492., 3774., 3936., 3945., 4116.,
      5232., 5448., 5421., 5646., 6956., 7256., 4971., 5196., 5142., 5376.,
      6608., 6896., 6812., 7112., 8720., 9120., 6212., 6512., 6392., 6704.,
      3504., 3720., 3621., 3846., 4556., 4856., 3171., 3396., 3270., 3504.,
      4323., 4602., 4440., 4728., 5564., 5948., 3864., 4152., 3963., 4260.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204., 240., 220., 260., 236., 280., 252., 300., 268., 320.,
      316., 380., 332., 400., 348., 420., 364., 440., 380., 460.,
      428., 520., 444., 540., 460., 560., 476., 580., 492., 600.,
      540., 660., 556., 680., 572., 700., 588., 720., 604., 740.,
      652., 800., 668., 820., 684., 840., 700., 860., 716., 880.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7665.,  7818.,  7971.,  8124.,  8034.,  8196.,  8358.,  8520.,  10336.,
      10552., 10768., 10984., 7386.,  7548.,  7710.,  7872.,  7719.,  7890.,
      8061.,  8232.,  10248., 10464., 10680., 10896., 10617., 10842., 11067.,
      11292., 13612., 13912., 14212., 14512., 9717.,  9942.,  10167., 10392.,
      10050., 10284., 10518., 10752., 12928., 13216., 13504., 13792., 13324.,
      13624., 13924., 14224., 17040., 17440., 17840., 18240., 12124., 12424.,
      12724., 13024., 12472., 12784., 13096., 13408., 6792.,  7008.,  7224.,
      7440.,  7017.,  7242.,  7467.,  7692.,  8812.,  9112.,  9412.,  9712.,
      6117.,  6342.,  6567.,  6792.,  6306.,  6540.,  6774.,  7008.,  8367.,
      8646.,  8925.,  9204.,  8592.,  8880.,  9168.,  9456.,  10744., 11128.,
      11512., 11896., 7440.,  7728.,  8016.,  8304.,  7629.,  7926.,  8223.,
      8520.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      372.,  408.,  444.,  480.,  400.,  440.,  480.,  520.,  428.,  472.,
      516.,  560.,  456.,  504.,  552.,  600.,  484.,  536.,  588.,  640.,
      568.,  632.,  696.,  760.,  596.,  664.,  732.,  800.,  624.,  696.,
      768.,  840.,  652.,  728.,  804.,  880.,  680.,  760.,  840.,  920.,
      764.,  856.,  948.,  1040., 792.,  888.,  984.,  1080., 820.,  920.,
      1020., 1120., 848.,  952.,  1056., 1160., 876.,  984.,  1092., 1200.,
      960.,  1080., 1200., 1320., 988.,  1112., 1236., 1360., 1016., 1144.,
      1272., 1400., 1044., 1176., 1308., 1440., 1072., 1208., 1344., 1480.,
      1156., 1304., 1452., 1600., 1184., 1336., 1488., 1640., 1212., 1368.,
      1524., 1680., 1240., 1400., 1560., 1720., 1268., 1432., 1596., 1760.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3963., 4062., 4161., 4260., 5366., 5492., 3846., 3936., 4026., 4116.,
      5349., 5448., 5547., 5646., 7130., 7256., 5106., 5196., 5286., 5376.,
      6788., 6896., 7004., 7112., 8984., 9120., 6416., 6512., 6608., 6704.,
      3657., 3720., 3783., 3846., 4778., 4856., 3342., 3396., 3450., 3504.,
      4539., 4602., 4665., 4728., 5870., 5948., 4098., 4152., 4206., 4260.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      230., 240., 250., 260., 270., 280., 290., 300., 310., 320.,
      370., 380., 390., 400., 410., 420., 430., 440., 450., 460.,
      510., 520., 530., 540., 550., 560., 570., 580., 590., 600.,
      650., 660., 670., 680., 690., 700., 710., 720., 730., 740.,
      790., 800., 810., 820., 830., 840., 850., 860., 870., 880.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7629.,  7926.,  7818.,  8124.,  8007.,  8322.,  8196.,  8520.,  10312.,
      10732., 10552., 10984., 7377.,  7692.,  7548.,  7872.,  7719.,  8052.,
      7890.,  8232.,  10275., 10698., 10464., 10896., 10653., 11094., 10842.,
      11292., 13672., 14260., 13912., 14512., 9771.,  10212., 9942.,  10392.,
      10113., 10572., 10284., 10752., 13012., 13576., 13216., 13792., 13420.,
      14008., 13624., 14224., 17184., 17968., 17440., 18240., 12244., 12832.,
      12424., 13024., 12604., 13216., 12784., 13408., 6891.,  7314.,  7008.,
      7440.,  7125.,  7566.,  7242.,  7692.,  8968.,  9556.,  9112.,  9712.,
      6243.,  6684.,  6342.,  6792.,  6441.,  6900.,  6540.,  7008.,  8529.,
      9078.,  8646.,  9204.,  8763.,  9330.,  8880.,  9456.,  10984., 11740.,
      11128., 11896., 7629.,  8196.,  7728.,  8304.,  7827.,  8412.,  7926.,
      8520.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      392.,  460.,  408.,  480.,  424.,  500.,  440.,  520.,  456.,  540.,
      472.,  560.,  488.,  580.,  504.,  600.,  520.,  620.,  536.,  640.,
      616.,  740.,  632.,  760.,  648.,  780.,  664.,  800.,  680.,  820.,
      696.,  840.,  712.,  860.,  728.,  880.,  744.,  900.,  760.,  920.,
      840.,  1020., 856.,  1040., 872.,  1060., 888.,  1080., 904.,  1100.,
      920.,  1120., 936.,  1140., 952.,  1160., 968.,  1180., 984.,  1200.,
      1064., 1300., 1080., 1320., 1096., 1340., 1112., 1360., 1128., 1380.,
      1144., 1400., 1160., 1420., 1176., 1440., 1192., 1460., 1208., 1480.,
      1288., 1580., 1304., 1600., 1320., 1620., 1336., 1640., 1352., 1660.,
      1368., 1680., 1384., 1700., 1400., 1720., 1416., 1740., 1432., 1760.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14961., 15258., 15555., 15852., 15330., 15636., 15942., 16248., 15699.,
      16014., 16329., 16644., 16068., 16392., 16716., 17040., 20204., 20624.,
      21044., 21464., 20672., 21104., 21536., 21968., 14439., 14754., 15069.,
      15384., 14772., 15096., 15420., 15744., 15105., 15438., 15771., 16104.,
      15438., 15780., 16122., 16464., 20127., 20550., 20973., 21396., 20496.,
      20928., 21360., 21792., 20865., 21306., 21747., 22188., 21234., 21684.,
      22134., 22584., 26756., 27344., 27932., 28520., 27224., 27824., 28424.,
      29024., 19101., 19542., 19983., 20424., 19434., 19884., 20334., 20784.,
      19767., 20226., 20685., 21144., 20100., 20568., 21036., 21504., 25460.,
      26024., 26588., 27152., 25856., 26432., 27008., 27584., 26252., 26840.,
      27428., 28016., 26648., 27248., 27848., 28448., 33584., 34368., 35152.,
      35936., 34080., 34880., 35680., 36480., 23900., 24488., 25076., 25664.,
      24248., 24848., 25448., 26048., 24596., 25208., 25820., 26432., 24944.,
      25568., 26192., 26816., 13359., 13782., 14205., 14628., 13584., 14016.,
      14448., 14880., 13809., 14250., 14691., 15132., 14034., 14484., 14934.,
      15384., 17348., 17936., 18524., 19112., 17624., 18224., 18824., 19424.,
      12045., 12486., 12927., 13368., 12234., 12684., 13134., 13584., 12423.,
      12882., 13341., 13800., 12612., 13080., 13548., 14016., 16509., 17058.,
      17607., 18156., 16734., 17292., 17850., 18408., 16959., 17526., 18093.,
      18660., 17184., 17760., 18336., 18912., 21212., 21968., 22724., 23480.,
      21488., 22256., 23024., 23792., 14691., 15258., 15825., 16392., 14880.,
      15456., 16032., 16608., 15069., 15654., 16239., 16824., 15258., 15852.,
      16446., 17040.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      716.,  784.,  852.,  920.,  744.,  816.,  888.,  960.,  772.,  848.,
      924.,  1000., 800.,  880.,  960.,  1040., 828.,  912.,  996.,  1080.,
      856.,  944.,  1032., 1120., 884.,  976.,  1068., 1160., 912.,  1008.,
      1104., 1200., 940.,  1040., 1140., 1240., 968.,  1072., 1176., 1280.,
      1108., 1232., 1356., 1480., 1136., 1264., 1392., 1520., 1164., 1296.,
      1428., 1560., 1192., 1328., 1464., 1600., 1220., 1360., 1500., 1640.,
      1248., 1392., 1536., 1680., 1276., 1424., 1572., 1720., 1304., 1456.,
      1608., 1760., 1332., 1488., 1644., 1800., 1360., 1520., 1680., 1840.,
      1500., 1680., 1860., 2040., 1528., 1712., 1896., 2080., 1556., 1744.,
      1932., 2120., 1584., 1776., 1968., 2160., 1612., 1808., 2004., 2200.,
      1640., 1840., 2040., 2240., 1668., 1872., 2076., 2280., 1696., 1904.,
      2112., 2320., 1724., 1936., 2148., 2360., 1752., 1968., 2184., 2400.,
      1892., 2128., 2364., 2600., 1920., 2160., 2400., 2640., 1948., 2192.,
      2436., 2680., 1976., 2224., 2472., 2720., 2004., 2256., 2508., 2760.,
      2032., 2288., 2544., 2800., 2060., 2320., 2580., 2840., 2088., 2352.,
      2616., 2880., 2116., 2384., 2652., 2920., 2144., 2416., 2688., 2960.,
      2284., 2576., 2868., 3160., 2312., 2608., 2904., 3200., 2340., 2640.,
      2940., 3240., 2368., 2672., 2976., 3280., 2396., 2704., 3012., 3320.,
      2424., 2736., 3048., 3360., 2452., 2768., 3084., 3400., 2480., 2800.,
      3120., 3440., 2508., 2832., 3156., 3480., 2536., 2864., 3192., 3520.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7827.,  7926.,  8025.,  8124.,  8223.,  8322.,  8421.,  8520.,  10606.,
      10732., 10858., 10984., 7602.,  7692.,  7782.,  7872.,  7962.,  8052.,
      8142.,  8232.,  10599., 10698., 10797., 10896., 10995., 11094., 11193.,
      11292., 14134., 14260., 14386., 14512., 10122., 10212., 10302., 10392.,
      10482., 10572., 10662., 10752., 13468., 13576., 13684., 13792., 13900.,
      14008., 14116., 14224., 17832., 17968., 18104., 18240., 12736., 12832.,
      12928., 13024., 13120., 13216., 13312., 13408., 7251.,  7314.,  7377.,
      7440.,  7503.,  7566.,  7629.,  7692.,  9478.,  9556.,  9634.,  9712.,
      6630.,  6684.,  6738.,  6792.,  6846.,  6900.,  6954.,  7008.,  9015.,
      9078.,  9141.,  9204.,  9267.,  9330.,  9393.,  9456.,  11662., 11740.,
      11818., 11896., 8142.,  8196.,  8250.,  8304.,  8358.,  8412.,  8466.,
      8520.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      450.,  460.,  470.,  480.,  490.,  500.,  510.,  520.,  530.,  540.,
      550.,  560.,  570.,  580.,  590.,  600.,  610.,  620.,  630.,  640.,
      730.,  740.,  750.,  760.,  770.,  780.,  790.,  800.,  810.,  820.,
      830.,  840.,  850.,  860.,  870.,  880.,  890.,  900.,  910.,  920.,
      1010., 1020., 1030., 1040., 1050., 1060., 1070., 1080., 1090., 1100.,
      1110., 1120., 1130., 1140., 1150., 1160., 1170., 1180., 1190., 1200.,
      1290., 1300., 1310., 1320., 1330., 1340., 1350., 1360., 1370., 1380.,
      1390., 1400., 1410., 1420., 1430., 1440., 1450., 1460., 1470., 1480.,
      1570., 1580., 1590., 1600., 1610., 1620., 1630., 1640., 1650., 1660.,
      1670., 1680., 1690., 1700., 1710., 1720., 1730., 1740., 1750., 1760.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15069., 15654., 15258., 15852., 15447., 16050., 15636., 16248., 15825.,
      16446., 16014., 16644., 16203., 16842., 16392., 17040., 20384., 21212.,
      20624., 21464., 20864., 21716., 21104., 21968., 14583., 15204., 14754.,
      15384., 14925., 15564., 15096., 15744., 15267., 15924., 15438., 16104.,
      15609., 16284., 15780., 16464., 20361., 21198., 20550., 21396., 20739.,
      21594., 20928., 21792., 21117., 21990., 21306., 22188., 21495., 22386.,
      21684., 22584., 27104., 28268., 27344., 28520., 27584., 28772., 27824.,
      29024., 19371., 20244., 19542., 20424., 19713., 20604., 19884., 20784.,
      20055., 20964., 20226., 21144., 20397., 21324., 20568., 21504., 25820.,
      26936., 26024., 27152., 26228., 27368., 26432., 27584., 26636., 27800.,
      26840., 28016., 27044., 28232., 27248., 28448., 34112., 35664., 34368.,
      35936., 34624., 36208., 34880., 36480., 24308., 25472., 24488., 25664.,
      24668., 25856., 24848., 26048., 25028., 26240., 25208., 26432., 25388.,
      26624., 25568., 26816., 13665., 14502., 13782., 14628., 13899., 14754.,
      14016., 14880., 14133., 15006., 14250., 15132., 14367., 15258., 14484.,
      15384., 17792., 18956., 17936., 19112., 18080., 19268., 18224., 19424.,
      12387., 13260., 12486., 13368., 12585., 13476., 12684., 13584., 12783.,
      13692., 12882., 13800., 12981., 13908., 13080., 14016., 16941., 18030.,
      17058., 18156., 17175., 18282., 17292., 18408., 17409., 18534., 17526.,
      18660., 17643., 18786., 17760., 18912., 21824., 23324., 21968., 23480.,
      22112., 23636., 22256., 23792., 15159., 16284., 15258., 16392., 15357.,
      16500., 15456., 16608., 15555., 16716., 15654., 16824., 15753., 16932.,
      15852., 17040.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      768.,  900.,  784.,  920.,  800.,  940.,  816.,  960.,  832.,  980.,
      848.,  1000., 864.,  1020., 880.,  1040., 896.,  1060., 912.,  1080.,
      928.,  1100., 944.,  1120., 960.,  1140., 976.,  1160., 992.,  1180.,
      1008., 1200., 1024., 1220., 1040., 1240., 1056., 1260., 1072., 1280.,
      1216., 1460., 1232., 1480., 1248., 1500., 1264., 1520., 1280., 1540.,
      1296., 1560., 1312., 1580., 1328., 1600., 1344., 1620., 1360., 1640.,
      1376., 1660., 1392., 1680., 1408., 1700., 1424., 1720., 1440., 1740.,
      1456., 1760., 1472., 1780., 1488., 1800., 1504., 1820., 1520., 1840.,
      1664., 2020., 1680., 2040., 1696., 2060., 1712., 2080., 1728., 2100.,
      1744., 2120., 1760., 2140., 1776., 2160., 1792., 2180., 1808., 2200.,
      1824., 2220., 1840., 2240., 1856., 2260., 1872., 2280., 1888., 2300.,
      1904., 2320., 1920., 2340., 1936., 2360., 1952., 2380., 1968., 2400.,
      2112., 2580., 2128., 2600., 2144., 2620., 2160., 2640., 2176., 2660.,
      2192., 2680., 2208., 2700., 2224., 2720., 2240., 2740., 2256., 2760.,
      2272., 2780., 2288., 2800., 2304., 2820., 2320., 2840., 2336., 2860.,
      2352., 2880., 2368., 2900., 2384., 2920., 2400., 2940., 2416., 2960.,
      2560., 3140., 2576., 3160., 2592., 3180., 2608., 3200., 2624., 3220.,
      2640., 3240., 2656., 3260., 2672., 3280., 2688., 3300., 2704., 3320.,
      2720., 3340., 2736., 3360., 2752., 3380., 2768., 3400., 2784., 3420.,
      2800., 3440., 2816., 3460., 2832., 3480., 2848., 3500., 2864., 3520.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29553., 30138., 30723., 31308., 29922., 30516., 31110., 31704., 30291.,
      30894., 31497., 32100., 30660., 31272., 31884., 32496., 31029., 31650.,
      32271., 32892., 31398., 32028., 32658., 33288., 31767., 32406., 33045.,
      33684., 32136., 32784., 33432., 34080., 39940., 40768., 41596., 42424.,
      40408., 41248., 42088., 42928., 40876., 41728., 42580., 43432., 41344.,
      42208., 43072., 43936., 28545., 29166., 29787., 30408., 28878., 29508.,
      30138., 30768., 29211., 29850., 30489., 31128., 29544., 30192., 30840.,
      31488., 29877., 30534., 31191., 31848., 30210., 30876., 31542., 32208.,
      30543., 31218., 31893., 32568., 30876., 31560., 32244., 32928., 39885.,
      40722., 41559., 42396., 40254., 41100., 41946., 42792., 40623., 41478.,
      42333., 43188., 40992., 41856., 42720., 43584., 41361., 42234., 43107.,
      43980., 41730., 42612., 43494., 44376., 42099., 42990., 43881., 44772.,
      42468., 43368., 44268., 45168., 53044., 54208., 55372., 56536., 53512.,
      54688., 55864., 57040., 53980., 55168., 56356., 57544., 54448., 55648.,
      56848., 58048., 37869., 38742., 39615., 40488., 38202., 39084., 39966.,
      40848., 38535., 39426., 40317., 41208., 38868., 39768., 40668., 41568.,
      39201., 40110., 41019., 41928., 39534., 40452., 41370., 42288., 39867.,
      40794., 41721., 42648., 40200., 41136., 42072., 43008., 50524., 51640.,
      52756., 53872., 50920., 52048., 53176., 54304., 51316., 52456., 53596.,
      54736., 51712., 52864., 54016., 55168., 52108., 53272., 54436., 55600.,
      52504., 53680., 54856., 56032., 52900., 54088., 55276., 56464., 53296.,
      54496., 55696., 56896., 66672., 68224., 69776., 71328., 67168., 68736.,
      70304., 71872., 67664., 69248., 70832., 72416., 68160., 69760., 71360.,
      72960., 47452., 48616., 49780., 50944., 47800., 48976., 50152., 51328.,
      48148., 49336., 50524., 51712., 48496., 49696., 50896., 52096., 48844.,
      50056., 51268., 52480., 49192., 50416., 51640., 52864., 49540., 50776.,
      52012., 53248., 49888., 51136., 52384., 53632., 26493., 27330., 28167.,
      29004., 26718., 27564., 28410., 29256., 26943., 27798., 28653., 29508.,
      27168., 28032., 28896., 29760., 27393., 28266., 29139., 30012., 27618.,
      28500., 29382., 30264., 27843., 28734., 29625., 30516., 28068., 28968.,
      29868., 30768., 34420., 35584., 36748., 37912., 34696., 35872., 37048.,
      38224., 34972., 36160., 37348., 38536., 35248., 36448., 37648., 38848.,
      23901., 24774., 25647., 26520., 24090., 24972., 25854., 26736., 24279.,
      25170., 26061., 26952., 24468., 25368., 26268., 27168., 24657., 25566.,
      26475., 27384., 24846., 25764., 26682., 27600., 25035., 25962., 26889.,
      27816., 25224., 26160., 27096., 28032., 32793., 33882., 34971., 36060.,
      33018., 34116., 35214., 36312., 33243., 34350., 35457., 36564., 33468.,
      34584., 35700., 36816., 33693., 34818., 35943., 37068., 33918., 35052.,
      36186., 37320., 34143., 35286., 36429., 37572., 34368., 35520., 36672.,
      37824., 42148., 43648., 45148., 46648., 42424., 43936., 45448., 46960.,
      42700., 44224., 45748., 47272., 42976., 44512., 46048., 47584., 29193.,
      30318., 31443., 32568., 29382., 30516., 31650., 32784., 29571., 30714.,
      31857., 33000., 29760., 30912., 32064., 33216., 29949., 31110., 32271.,
      33432., 30138., 31308., 32478., 33648., 30327., 31506., 32685., 33864.,
      30516., 31704., 32892., 34080.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1404., 1536., 1668., 1800., 1432., 1568., 1704., 1840., 1460., 1600.,
      1740., 1880., 1488., 1632., 1776., 1920., 1516., 1664., 1812., 1960.,
      1544., 1696., 1848., 2000., 1572., 1728., 1884., 2040., 1600., 1760.,
      1920., 2080., 1628., 1792., 1956., 2120., 1656., 1824., 1992., 2160.,
      1684., 1856., 2028., 2200., 1712., 1888., 2064., 2240., 1740., 1920.,
      2100., 2280., 1768., 1952., 2136., 2320., 1796., 1984., 2172., 2360.,
      1824., 2016., 2208., 2400., 1852., 2048., 2244., 2440., 1880., 2080.,
      2280., 2480., 1908., 2112., 2316., 2520., 1936., 2144., 2352., 2560.,
      2188., 2432., 2676., 2920., 2216., 2464., 2712., 2960., 2244., 2496.,
      2748., 3000., 2272., 2528., 2784., 3040., 2300., 2560., 2820., 3080.,
      2328., 2592., 2856., 3120., 2356., 2624., 2892., 3160., 2384., 2656.,
      2928., 3200., 2412., 2688., 2964., 3240., 2440., 2720., 3000., 3280.,
      2468., 2752., 3036., 3320., 2496., 2784., 3072., 3360., 2524., 2816.,
      3108., 3400., 2552., 2848., 3144., 3440., 2580., 2880., 3180., 3480.,
      2608., 2912., 3216., 3520., 2636., 2944., 3252., 3560., 2664., 2976.,
      3288., 3600., 2692., 3008., 3324., 3640., 2720., 3040., 3360., 3680.,
      2972., 3328., 3684., 4040., 3000., 3360., 3720., 4080., 3028., 3392.,
      3756., 4120., 3056., 3424., 3792., 4160., 3084., 3456., 3828., 4200.,
      3112., 3488., 3864., 4240., 3140., 3520., 3900., 4280., 3168., 3552.,
      3936., 4320., 3196., 3584., 3972., 4360., 3224., 3616., 4008., 4400.,
      3252., 3648., 4044., 4440., 3280., 3680., 4080., 4480., 3308., 3712.,
      4116., 4520., 3336., 3744., 4152., 4560., 3364., 3776., 4188., 4600.,
      3392., 3808., 4224., 4640., 3420., 3840., 4260., 4680., 3448., 3872.,
      4296., 4720., 3476., 3904., 4332., 4760., 3504., 3936., 4368., 4800.,
      3756., 4224., 4692., 5160., 3784., 4256., 4728., 5200., 3812., 4288.,
      4764., 5240., 3840., 4320., 4800., 5280., 3868., 4352., 4836., 5320.,
      3896., 4384., 4872., 5360., 3924., 4416., 4908., 5400., 3952., 4448.,
      4944., 5440., 3980., 4480., 4980., 5480., 4008., 4512., 5016., 5520.,
      4036., 4544., 5052., 5560., 4064., 4576., 5088., 5600., 4092., 4608.,
      5124., 5640., 4120., 4640., 5160., 5680., 4148., 4672., 5196., 5720.,
      4176., 4704., 5232., 5760., 4204., 4736., 5268., 5800., 4232., 4768.,
      5304., 5840., 4260., 4800., 5340., 5880., 4288., 4832., 5376., 5920.,
      4540., 5120., 5700., 6280., 4568., 5152., 5736., 6320., 4596., 5184.,
      5772., 6360., 4624., 5216., 5808., 6400., 4652., 5248., 5844., 6440.,
      4680., 5280., 5880., 6480., 4708., 5312., 5916., 6520., 4736., 5344.,
      5952., 6560., 4764., 5376., 5988., 6600., 4792., 5408., 6024., 6640.,
      4820., 5440., 6060., 6680., 4848., 5472., 6096., 6720., 4876., 5504.,
      6132., 6760., 4904., 5536., 6168., 6800., 4932., 5568., 6204., 6840.,
      4960., 5600., 6240., 6880., 4988., 5632., 6276., 6920., 5016., 5664.,
      6312., 6960., 5044., 5696., 6348., 7000., 5072., 5728., 6384., 7040.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2376., 3062., 3188., 2286., 2376., 3168., 4070., 4196., 3006.,
      3096., 4000., 5128., 5264., 3760., 3856., 2160., 2726., 2804.,
      1962., 2016., 2664., 3350., 3428., 2394., 2448.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      134., 144., 154., 164., 174., 214., 224., 234., 244.,
      254., 294., 304., 314., 324., 334., 374., 384., 394.,
      404., 414., 454., 464., 474., 484., 494.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4572., 4752., 5884., 6124.,  6124.,  6376.,  4383., 4572., 4554., 4752.,
      6084., 6336., 7804., 8140.,  8044.,  8392.,  5751., 6012., 5922., 6192.,
      7664., 8000., 9808., 10256., 10064., 10528., 7172., 7520., 7352., 7712.,
      4068., 4320., 5116., 5452.,  5260.,  5608.,  3663., 3924., 3762., 4032.,
      5004., 5328., 6268., 6700.,  6412.,  6856.,  4455., 4788., 4554., 4896.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      228., 268., 244., 288., 260., 308., 276., 328., 292., 348.,
      356., 428., 372., 448., 388., 468., 404., 488., 420., 508.,
      484., 588., 500., 608., 516., 628., 532., 648., 548., 668.,
      612., 748., 628., 768., 644., 788., 660., 808., 676., 828.,
      740., 908., 756., 928., 772., 948., 788., 968., 804., 988.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8964.,  9144.,  9324.,  9504.,  11528., 11768., 12008., 12248., 11996.,
      12248., 12500., 12752., 8577.,  8766.,  8955.,  9144.,  8910.,  9108.,
      9306.,  9504.,  11916., 12168., 12420., 12672., 15272., 15608., 15944.,
      16280., 15740., 16088., 16436., 16784., 11241., 11502., 11763., 12024.,
      11574., 11844., 12114., 12384., 14992., 15328., 15664., 16000., 19168.,
      19616., 20064., 20512., 19664., 20128., 20592., 21056., 13996., 14344.,
      14692., 15040., 14344., 14704., 15064., 15424., 7884.,  8136.,  8388.,
      8640.,  9896.,  10232., 10568., 10904., 10172., 10520., 10868., 11216.,
      7065.,  7326.,  7587.,  7848.,  7254.,  7524.,  7794.,  8064.,  9684.,
      10008., 10332., 10656., 12104., 12536., 12968., 13400., 12380., 12824.,
      13268., 13712., 8577.,  8910.,  9243.,  9576.,  8766.,  9108.,  9450.,
      9792.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      416.,  456.,  496.,  536.,  444.,  488.,  532.,  576.,  472.,  520.,
      568.,  616.,  500.,  552.,  604.,  656.,  528.,  584.,  640.,  696.,
      640.,  712.,  784.,  856.,  668.,  744.,  820.,  896.,  696.,  776.,
      856.,  936.,  724.,  808.,  892.,  976.,  752.,  840.,  928.,  1016.,
      864.,  968.,  1072., 1176., 892.,  1000., 1108., 1216., 920.,  1032.,
      1144., 1256., 948.,  1064., 1180., 1296., 976.,  1096., 1216., 1336.,
      1088., 1224., 1360., 1496., 1116., 1256., 1396., 1536., 1144., 1288.,
      1432., 1576., 1172., 1320., 1468., 1616., 1200., 1352., 1504., 1656.,
      1312., 1480., 1648., 1816., 1340., 1512., 1684., 1856., 1368., 1544.,
      1720., 1896., 1396., 1576., 1756., 1936., 1424., 1608., 1792., 1976.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4653., 4752., 5998.,  6124.,  6250.,  6376.,  4482., 4572., 4662., 4752.,
      6237., 6336., 8014.,  8140.,  8266.,  8392.,  5922., 6012., 6102., 6192.,
      7892., 8000., 10120., 10256., 10392., 10528., 7424., 7520., 7616., 7712.,
      4257., 4320., 5374.,  5452.,  5530.,  5608.,  3870., 3924., 3978., 4032.,
      5265., 5328., 6622.,  6700.,  6778.,  6856.,  4734., 4788., 4842., 4896.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      258., 268., 278., 288., 298., 308., 318., 328., 338., 348.,
      418., 428., 438., 448., 458., 468., 478., 488., 498., 508.,
      578., 588., 598., 608., 618., 628., 638., 648., 658., 668.,
      738., 748., 758., 768., 778., 788., 798., 808., 818., 828.,
      898., 908., 918., 928., 938., 948., 958., 968., 978., 988.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8955.,  9306.,  9144.,  9504.,  11528., 11996., 11768., 12248., 12008.,
      12500., 12248., 12752., 8595.,  8964.,  8766.,  9144.,  8937.,  9324.,
      9108.,  9504.,  11979., 12474., 12168., 12672., 15368., 16028., 15608.,
      16280., 15848., 16532., 16088., 16784., 11331., 11844., 11502., 12024.,
      11673., 12204., 11844., 12384., 15124., 15784., 15328., 16000., 19360.,
      20240., 19616., 20512., 19872., 20784., 20128., 21056., 14164., 14848.,
      14344., 15040., 14524., 15232., 14704., 15424., 8019.,  8514.,  8136.,
      8640.,  10088., 10748., 10232., 10904., 10376., 11060., 10520., 11216.,
      7227.,  7740.,  7326.,  7848.,  7425.,  7956.,  7524.,  8064.,  9891.,
      10530., 10008., 10656., 12392., 13244., 12536., 13400., 12680., 13556.,
      12824., 13712., 8811.,  9468.,  8910.,  9576.,  9009.,  9684.,  9108.,
      9792.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      440.,  516.,  456.,  536.,  472.,  556.,  488.,  576.,  504.,  596.,
      520.,  616.,  536.,  636.,  552.,  656.,  568.,  676.,  584.,  696.,
      696.,  836.,  712.,  856.,  728.,  876.,  744.,  896.,  760.,  916.,
      776.,  936.,  792.,  956.,  808.,  976.,  824.,  996.,  840.,  1016.,
      952.,  1156., 968.,  1176., 984.,  1196., 1000., 1216., 1016., 1236.,
      1032., 1256., 1048., 1276., 1064., 1296., 1080., 1316., 1096., 1336.,
      1208., 1476., 1224., 1496., 1240., 1516., 1256., 1536., 1272., 1556.,
      1288., 1576., 1304., 1596., 1320., 1616., 1336., 1636., 1352., 1656.,
      1464., 1796., 1480., 1816., 1496., 1836., 1512., 1856., 1528., 1876.,
      1544., 1896., 1560., 1916., 1576., 1936., 1592., 1956., 1608., 1976.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17559., 17910., 18261., 18612., 17928., 18288., 18648., 19008., 22588.,
      23056., 23524., 23992., 23056., 23536., 24016., 24496., 23524., 24016.,
      24508., 25000., 23992., 24496., 25000., 25504., 16821., 17190., 17559.,
      17928., 17154., 17532., 17910., 18288., 17487., 17874., 18261., 18648.,
      17820., 18216., 18612., 19008., 23463., 23958., 24453., 24948., 23832.,
      24336., 24840., 25344., 30076., 30736., 31396., 32056., 30544., 31216.,
      31888., 32560., 31012., 31696., 32380., 33064., 31480., 32176., 32872.,
      33568., 22149., 22662., 23175., 23688., 22482., 23004., 23526., 24048.,
      22815., 23346., 23877., 24408., 23148., 23688., 24228., 24768., 29588.,
      30248., 30908., 31568., 29984., 30656., 31328., 32000., 37840., 38720.,
      39600., 40480., 38336., 39232., 40128., 41024., 38832., 39744., 40656.,
      41568., 39328., 40256., 41184., 42112., 27644., 28328., 29012., 29696.,
      27992., 28688., 29384., 30080., 28340., 29048., 29756., 30464., 28688.,
      29408., 30128., 30848., 15543., 16038., 16533., 17028., 15768., 16272.,
      16776., 17280., 19516., 20176., 20836., 21496., 19792., 20464., 21136.,
      21808., 20068., 20752., 21436., 22120., 20344., 21040., 21736., 22432.,
      13941., 14454., 14967., 15480., 14130., 14652., 15174., 15696., 14319.,
      14850., 15381., 15912., 14508., 15048., 15588., 16128., 19143., 19782.,
      20421., 21060., 19368., 20016., 20664., 21312., 23932., 24784., 25636.,
      26488., 24208., 25072., 25936., 26800., 24484., 25360., 26236., 27112.,
      24760., 25648., 26536., 27424., 16965., 17622., 18279., 18936., 17154.,
      17820., 18486., 19152., 17343., 18018., 18693., 19368., 17532., 18216.,
      18900., 19584.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      804.,  880.,  956.,  1032., 832.,  912.,  992.,  1072., 860.,  944.,
      1028., 1112., 888.,  976.,  1064., 1152., 916.,  1008., 1100., 1192.,
      944.,  1040., 1136., 1232., 972.,  1072., 1172., 1272., 1000., 1104.,
      1208., 1312., 1028., 1136., 1244., 1352., 1056., 1168., 1280., 1392.,
      1252., 1392., 1532., 1672., 1280., 1424., 1568., 1712., 1308., 1456.,
      1604., 1752., 1336., 1488., 1640., 1792., 1364., 1520., 1676., 1832.,
      1392., 1552., 1712., 1872., 1420., 1584., 1748., 1912., 1448., 1616.,
      1784., 1952., 1476., 1648., 1820., 1992., 1504., 1680., 1856., 2032.,
      1700., 1904., 2108., 2312., 1728., 1936., 2144., 2352., 1756., 1968.,
      2180., 2392., 1784., 2000., 2216., 2432., 1812., 2032., 2252., 2472.,
      1840., 2064., 2288., 2512., 1868., 2096., 2324., 2552., 1896., 2128.,
      2360., 2592., 1924., 2160., 2396., 2632., 1952., 2192., 2432., 2672.,
      2148., 2416., 2684., 2952., 2176., 2448., 2720., 2992., 2204., 2480.,
      2756., 3032., 2232., 2512., 2792., 3072., 2260., 2544., 2828., 3112.,
      2288., 2576., 2864., 3152., 2316., 2608., 2900., 3192., 2344., 2640.,
      2936., 3232., 2372., 2672., 2972., 3272., 2400., 2704., 3008., 3312.,
      2596., 2928., 3260., 3592., 2624., 2960., 3296., 3632., 2652., 2992.,
      3332., 3672., 2680., 3024., 3368., 3712., 2708., 3056., 3404., 3752.,
      2736., 3088., 3440., 3792., 2764., 3120., 3476., 3832., 2792., 3152.,
      3512., 3872., 2820., 3184., 3548., 3912., 2848., 3216., 3584., 3952.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9207.,  9306.,  9405.,  9504.,  11870., 11996., 12122., 12248., 12374.,
      12500., 12626., 12752., 8874.,  8964.,  9054.,  9144.,  9234.,  9324.,
      9414.,  9504.,  12375., 12474., 12573., 12672., 15902., 16028., 16154.,
      16280., 16406., 16532., 16658., 16784., 11754., 11844., 11934., 12024.,
      12114., 12204., 12294., 12384., 15676., 15784., 15892., 16000., 20104.,
      20240., 20376., 20512., 20648., 20784., 20920., 21056., 14752., 14848.,
      14944., 15040., 15136., 15232., 15328., 15424., 8451.,  8514.,  8577.,
      8640.,  10670., 10748., 10826., 10904., 10982., 11060., 11138., 11216.,
      7686.,  7740.,  7794.,  7848.,  7902.,  7956.,  8010.,  8064.,  10467.,
      10530., 10593., 10656., 13166., 13244., 13322., 13400., 13478., 13556.,
      13634., 13712., 9414.,  9468.,  9522.,  9576.,  9630.,  9684.,  9738.,
      9792.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      506.,  516.,  526.,  536.,  546.,  556.,  566.,  576.,  586.,  596.,
      606.,  616.,  626.,  636.,  646.,  656.,  666.,  676.,  686.,  696.,
      826.,  836.,  846.,  856.,  866.,  876.,  886.,  896.,  906.,  916.,
      926.,  936.,  946.,  956.,  966.,  976.,  986.,  996.,  1006., 1016.,
      1146., 1156., 1166., 1176., 1186., 1196., 1206., 1216., 1226., 1236.,
      1246., 1256., 1266., 1276., 1286., 1296., 1306., 1316., 1326., 1336.,
      1466., 1476., 1486., 1496., 1506., 1516., 1526., 1536., 1546., 1556.,
      1566., 1576., 1586., 1596., 1606., 1616., 1626., 1636., 1646., 1656.,
      1786., 1796., 1806., 1816., 1826., 1836., 1846., 1856., 1866., 1876.,
      1886., 1896., 1906., 1916., 1926., 1936., 1946., 1956., 1966., 1976.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17721., 18414., 17910., 18612., 18099., 18810., 18288., 19008., 22816.,
      23740., 23056., 23992., 23296., 24244., 23536., 24496., 23776., 24748.,
      24016., 25000., 24256., 25252., 24496., 25504., 17019., 17748., 17190.,
      17928., 17361., 18108., 17532., 18288., 17703., 18468., 17874., 18648.,
      18045., 18828., 18216., 19008., 23769., 24750., 23958., 24948., 24147.,
      25146., 24336., 25344., 30496., 31804., 30736., 32056., 30976., 32308.,
      31216., 32560., 31456., 32812., 31696., 33064., 31936., 33316., 32176.,
      33568., 22491., 23508., 22662., 23688., 22833., 23868., 23004., 24048.,
      23175., 24228., 23346., 24408., 23517., 24588., 23688., 24768., 30044.,
      31352., 30248., 31568., 30452., 31784., 30656., 32000., 38464., 40208.,
      38720., 40480., 38976., 40752., 39232., 41024., 39488., 41296., 39744.,
      41568., 40000., 41840., 40256., 42112., 28148., 29504., 28328., 29696.,
      28508., 29888., 28688., 30080., 28868., 30272., 29048., 30464., 29228.,
      30656., 29408., 30848., 15921., 16902., 16038., 17028., 16155., 17154.,
      16272., 17280., 20032., 21340., 20176., 21496., 20320., 21652., 20464.,
      21808., 20608., 21964., 20752., 22120., 20896., 22276., 21040., 22432.,
      14355., 15372., 14454., 15480., 14553., 15588., 14652., 15696., 14751.,
      15804., 14850., 15912., 14949., 16020., 15048., 16128., 19665., 20934.,
      19782., 21060., 19899., 21186., 20016., 21312., 24640., 26332., 24784.,
      26488., 24928., 26644., 25072., 26800., 25216., 26956., 25360., 27112.,
      25504., 27268., 25648., 27424., 17523., 18828., 17622., 18936., 17721.,
      19044., 17820., 19152., 17919., 19260., 18018., 19368., 18117., 19476.,
      18216., 19584.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      864.,  1012., 880.,  1032., 896.,  1052., 912.,  1072., 928.,  1092.,
      944.,  1112., 960.,  1132., 976.,  1152., 992.,  1172., 1008., 1192.,
      1024., 1212., 1040., 1232., 1056., 1252., 1072., 1272., 1088., 1292.,
      1104., 1312., 1120., 1332., 1136., 1352., 1152., 1372., 1168., 1392.,
      1376., 1652., 1392., 1672., 1408., 1692., 1424., 1712., 1440., 1732.,
      1456., 1752., 1472., 1772., 1488., 1792., 1504., 1812., 1520., 1832.,
      1536., 1852., 1552., 1872., 1568., 1892., 1584., 1912., 1600., 1932.,
      1616., 1952., 1632., 1972., 1648., 1992., 1664., 2012., 1680., 2032.,
      1888., 2292., 1904., 2312., 1920., 2332., 1936., 2352., 1952., 2372.,
      1968., 2392., 1984., 2412., 2000., 2432., 2016., 2452., 2032., 2472.,
      2048., 2492., 2064., 2512., 2080., 2532., 2096., 2552., 2112., 2572.,
      2128., 2592., 2144., 2612., 2160., 2632., 2176., 2652., 2192., 2672.,
      2400., 2932., 2416., 2952., 2432., 2972., 2448., 2992., 2464., 3012.,
      2480., 3032., 2496., 3052., 2512., 3072., 2528., 3092., 2544., 3112.,
      2560., 3132., 2576., 3152., 2592., 3172., 2608., 3192., 2624., 3212.,
      2640., 3232., 2656., 3252., 2672., 3272., 2688., 3292., 2704., 3312.,
      2912., 3572., 2928., 3592., 2944., 3612., 2960., 3632., 2976., 3652.,
      2992., 3672., 3008., 3692., 3024., 3712., 3040., 3732., 3056., 3752.,
      3072., 3772., 3088., 3792., 3104., 3812., 3120., 3832., 3136., 3852.,
      3152., 3872., 3168., 3892., 3184., 3912., 3200., 3932., 3216., 3952.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34749., 35442., 36135., 36828., 35118., 35820., 36522., 37224., 35487.,
      36198., 36909., 37620., 35856., 36576., 37296., 38016., 44708., 45632.,
      46556., 47480., 45176., 46112., 47048., 47984., 45644., 46592., 47540.,
      48488., 46112., 47072., 48032., 48992., 46580., 47552., 48524., 49496.,
      47048., 48032., 49016., 50000., 47516., 48512., 49508., 50504., 47984.,
      48992., 50000., 51008., 33309., 34038., 34767., 35496., 33642., 34380.,
      35118., 35856., 33975., 34722., 35469., 36216., 34308., 35064., 35820.,
      36576., 34641., 35406., 36171., 36936., 34974., 35748., 36522., 37296.,
      35307., 36090., 36873., 37656., 35640., 36432., 37224., 38016., 46557.,
      47538., 48519., 49500., 46926., 47916., 48906., 49896., 47295., 48294.,
      49293., 50292., 47664., 48672., 49680., 50688., 59684., 60992., 62300.,
      63608., 60152., 61472., 62792., 64112., 60620., 61952., 63284., 64616.,
      61088., 62432., 63776., 65120., 61556., 62912., 64268., 65624., 62024.,
      63392., 64760., 66128., 62492., 63872., 65252., 66632., 62960., 64352.,
      65744., 67136., 43965., 44982., 45999., 47016., 44298., 45324., 46350.,
      47376., 44631., 45666., 46701., 47736., 44964., 46008., 47052., 48096.,
      45297., 46350., 47403., 48456., 45630., 46692., 47754., 48816., 45963.,
      47034., 48105., 49176., 46296., 47376., 48456., 49536., 58780., 60088.,
      61396., 62704., 59176., 60496., 61816., 63136., 59572., 60904., 62236.,
      63568., 59968., 61312., 62656., 64000., 75184., 76928., 78672., 80416.,
      75680., 77440., 79200., 80960., 76176., 77952., 79728., 81504., 76672.,
      78464., 80256., 82048., 77168., 78976., 80784., 82592., 77664., 79488.,
      81312., 83136., 78160., 80000., 81840., 83680., 78656., 80512., 82368.,
      84224., 54940., 56296., 57652., 59008., 55288., 56656., 58024., 59392.,
      55636., 57016., 58396., 59776., 55984., 57376., 58768., 60160., 56332.,
      57736., 59140., 60544., 56680., 58096., 59512., 60928., 57028., 58456.,
      59884., 61312., 57376., 58816., 60256., 61696., 30861., 31842., 32823.,
      33804., 31086., 32076., 33066., 34056., 31311., 32310., 33309., 34308.,
      31536., 32544., 33552., 34560., 38756., 40064., 41372., 42680., 39032.,
      40352., 41672., 42992., 39308., 40640., 41972., 43304., 39584., 40928.,
      42272., 43616., 39860., 41216., 42572., 43928., 40136., 41504., 42872.,
      44240., 40412., 41792., 43172., 44552., 40688., 42080., 43472., 44864.,
      27693., 28710., 29727., 30744., 27882., 28908., 29934., 30960., 28071.,
      29106., 30141., 31176., 28260., 29304., 30348., 31392., 28449., 29502.,
      30555., 31608., 28638., 29700., 30762., 31824., 28827., 29898., 30969.,
      32040., 29016., 30096., 31176., 32256., 38061., 39330., 40599., 41868.,
      38286., 39564., 40842., 42120., 38511., 39798., 41085., 42372., 38736.,
      40032., 41328., 42624., 47588., 49280., 50972., 52664., 47864., 49568.,
      51272., 52976., 48140., 49856., 51572., 53288., 48416., 50144., 51872.,
      53600., 48692., 50432., 52172., 53912., 48968., 50720., 52472., 54224.,
      49244., 51008., 52772., 54536., 49520., 51296., 53072., 54848., 33741.,
      35046., 36351., 37656., 33930., 35244., 36558., 37872., 34119., 35442.,
      36765., 38088., 34308., 35640., 36972., 38304., 34497., 35838., 37179.,
      38520., 34686., 36036., 37386., 38736., 34875., 36234., 37593., 38952.,
      35064., 36432., 37800., 39168.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1580., 1728., 1876., 2024., 1608., 1760., 1912., 2064., 1636., 1792.,
      1948., 2104., 1664., 1824., 1984., 2144., 1692., 1856., 2020., 2184.,
      1720., 1888., 2056., 2224., 1748., 1920., 2092., 2264., 1776., 1952.,
      2128., 2304., 1804., 1984., 2164., 2344., 1832., 2016., 2200., 2384.,
      1860., 2048., 2236., 2424., 1888., 2080., 2272., 2464., 1916., 2112.,
      2308., 2504., 1944., 2144., 2344., 2544., 1972., 2176., 2380., 2584.,
      2000., 2208., 2416., 2624., 2028., 2240., 2452., 2664., 2056., 2272.,
      2488., 2704., 2084., 2304., 2524., 2744., 2112., 2336., 2560., 2784.,
      2476., 2752., 3028., 3304., 2504., 2784., 3064., 3344., 2532., 2816.,
      3100., 3384., 2560., 2848., 3136., 3424., 2588., 2880., 3172., 3464.,
      2616., 2912., 3208., 3504., 2644., 2944., 3244., 3544., 2672., 2976.,
      3280., 3584., 2700., 3008., 3316., 3624., 2728., 3040., 3352., 3664.,
      2756., 3072., 3388., 3704., 2784., 3104., 3424., 3744., 2812., 3136.,
      3460., 3784., 2840., 3168., 3496., 3824., 2868., 3200., 3532., 3864.,
      2896., 3232., 3568., 3904., 2924., 3264., 3604., 3944., 2952., 3296.,
      3640., 3984., 2980., 3328., 3676., 4024., 3008., 3360., 3712., 4064.,
      3372., 3776., 4180., 4584., 3400., 3808., 4216., 4624., 3428., 3840.,
      4252., 4664., 3456., 3872., 4288., 4704., 3484., 3904., 4324., 4744.,
      3512., 3936., 4360., 4784., 3540., 3968., 4396., 4824., 3568., 4000.,
      4432., 4864., 3596., 4032., 4468., 4904., 3624., 4064., 4504., 4944.,
      3652., 4096., 4540., 4984., 3680., 4128., 4576., 5024., 3708., 4160.,
      4612., 5064., 3736., 4192., 4648., 5104., 3764., 4224., 4684., 5144.,
      3792., 4256., 4720., 5184., 3820., 4288., 4756., 5224., 3848., 4320.,
      4792., 5264., 3876., 4352., 4828., 5304., 3904., 4384., 4864., 5344.,
      4268., 4800., 5332., 5864., 4296., 4832., 5368., 5904., 4324., 4864.,
      5404., 5944., 4352., 4896., 5440., 5984., 4380., 4928., 5476., 6024.,
      4408., 4960., 5512., 6064., 4436., 4992., 5548., 6104., 4464., 5024.,
      5584., 6144., 4492., 5056., 5620., 6184., 4520., 5088., 5656., 6224.,
      4548., 5120., 5692., 6264., 4576., 5152., 5728., 6304., 4604., 5184.,
      5764., 6344., 4632., 5216., 5800., 6384., 4660., 5248., 5836., 6424.,
      4688., 5280., 5872., 6464., 4716., 5312., 5908., 6504., 4744., 5344.,
      5944., 6544., 4772., 5376., 5980., 6584., 4800., 5408., 6016., 6624.,
      5164., 5824., 6484., 7144., 5192., 5856., 6520., 7184., 5220., 5888.,
      6556., 7224., 5248., 5920., 6592., 7264., 5276., 5952., 6628., 7304.,
      5304., 5984., 6664., 7344., 5332., 6016., 6700., 7384., 5360., 6048.,
      6736., 7424., 5388., 6080., 6772., 7464., 5416., 6112., 6808., 7504.,
      5444., 6144., 6844., 7544., 5472., 6176., 6880., 7584., 5500., 6208.,
      6916., 7624., 5528., 6240., 6952., 7664., 5556., 6272., 6988., 7704.,
      5584., 6304., 7024., 7744., 5612., 6336., 7060., 7784., 5640., 6368.,
      7096., 7824., 5668., 6400., 7132., 7864., 5696., 6432., 7168., 7904.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4880., 5935., 6130., 4730.,  4880., 6500., 7885., 8080., 6230.,
      6380., 8200., 9930., 10140., 7800., 7960., 4400., 5260., 5380.,
      4070., 4160., 5420., 6460.,  6580., 4970., 5060.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      371.,  392.,  413.,  434.,  455.,  581.,  602.,  623.,  644.,
      665.,  791.,  812.,  833.,  854.,  875.,  1001., 1022., 1043.,
      1064., 1085., 1211., 1232., 1253., 1274., 1295.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9460.,  9760.,  11495., 11870., 11870., 12260., 9148.,  9460.,  9436.,
      9760.,  12580., 13000., 15245., 15770., 15620., 16160., 12028., 12460.,
      12316., 12760., 15840., 16400., 19160., 19860., 19560., 20280., 15024.,
      15600., 15328., 15920., 8380.,  8800.,  9995.,  10520., 10220., 10760.,
      7708.,  8140.,  7876.,  8320.,  10300., 10840., 12245., 12920., 12470.,
      13160., 9388.,  9940.,  9556.,  10120.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      664.,  742.,  700.,  784.,  736.,  826.,  772.,  868.,  808.,  910.,
      1024., 1162., 1060., 1204., 1096., 1246., 1132., 1288., 1168., 1330.,
      1384., 1582., 1420., 1624., 1456., 1666., 1492., 1708., 1528., 1750.,
      1744., 2002., 1780., 2044., 1816., 2086., 1852., 2128., 1888., 2170.,
      2104., 2422., 2140., 2464., 2176., 2506., 2212., 2548., 2248., 2590.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18620., 18920., 19220., 19520., 22615., 22990., 23365., 23740., 23350.,
      23740., 24130., 24520., 17984., 18296., 18608., 18920., 18548., 18872.,
      19196., 19520., 24740., 25160., 25580., 26000., 29965., 30490., 31015.,
      31540., 30700., 31240., 31780., 32320., 23624., 24056., 24488., 24920.,
      24188., 24632., 25076., 25520., 31120., 31680., 32240., 32800., 37620.,
      38320., 39020., 39720., 38400., 39120., 39840., 40560., 29472., 30048.,
      30624., 31200., 30064., 30656., 31248., 31840., 16340., 16760., 17180.,
      17600., 19465., 19990., 20515., 21040., 19900., 20440., 20980., 21520.,
      14984., 15416., 15848., 16280., 15308., 15752., 16196., 16640., 20060.,
      20600., 21140., 21680., 23815., 24490., 25165., 25840., 24250., 24940.,
      25630., 26320., 18224., 18776., 19328., 19880., 18548., 19112., 19676.,
      20240.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1250., 1328., 1406., 1484., 1316., 1400., 1484., 1568., 1382., 1472.,
      1562., 1652., 1448., 1544., 1640., 1736., 1514., 1616., 1718., 1820.,
      1910., 2048., 2186., 2324., 1976., 2120., 2264., 2408., 2042., 2192.,
      2342., 2492., 2108., 2264., 2420., 2576., 2174., 2336., 2498., 2660.,
      2570., 2768., 2966., 3164., 2636., 2840., 3044., 3248., 2702., 2912.,
      3122., 3332., 2768., 2984., 3200., 3416., 2834., 3056., 3278., 3500.,
      3230., 3488., 3746., 4004., 3296., 3560., 3824., 4088., 3362., 3632.,
      3902., 4172., 3428., 3704., 3980., 4256., 3494., 3776., 4058., 4340.,
      3890., 4208., 4526., 4844., 3956., 4280., 4604., 4928., 4022., 4352.,
      4682., 5012., 4088., 4424., 4760., 5096., 4154., 4496., 4838., 5180.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9598.,  9760.,  11675., 11870., 12065., 12260., 9310.,  9460.,  9610.,
      9760.,  12838., 13000., 15575., 15770., 15965., 16160., 12310., 12460.,
      12610., 12760., 16224., 16400., 19650., 19860., 20070., 20280., 15440.,
      15600., 15760., 15920., 8698.,  8800.,  10400., 10520., 10640., 10760.,
      8050.,  8140.,  8230.,  8320.,  10738., 10840., 12800., 12920., 13040.,
      13160., 9850.,  9940.,  10030., 10120.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      721.,  742.,  763.,  784.,  805.,  826.,  847.,  868.,  889.,  910.,
      1141., 1162., 1183., 1204., 1225., 1246., 1267., 1288., 1309., 1330.,
      1561., 1582., 1603., 1624., 1645., 1666., 1687., 1708., 1729., 1750.,
      1981., 2002., 2023., 2044., 2065., 2086., 2107., 2128., 2149., 2170.,
      2401., 2422., 2443., 2464., 2485., 2506., 2527., 2548., 2569., 2590.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18608., 19196., 18920., 19520., 22615., 23350., 22990., 23740., 23365.,
      24130., 23740., 24520., 18008., 18620., 18296., 18920., 18584., 19220.,
      18872., 19520., 24848., 25676., 25160., 26000., 30115., 31150., 30490.,
      31540., 30865., 31930., 31240., 32320., 23768., 24620., 24056., 24920.,
      24344., 25220., 24632., 25520., 31344., 32448., 31680., 32800., 37920.,
      39300., 38320., 39720., 38720., 40140., 39120., 40560., 29744., 30880.,
      30048., 31200., 30352., 31520., 30656., 31840., 16568., 17396., 16760.,
      17600., 19765., 20800., 19990., 21040., 20215., 21280., 20440., 21520.,
      15248., 16100., 15416., 16280., 15584., 16460., 15752., 16640., 20408.,
      21476., 20600., 21680., 24265., 25600., 24490., 25840., 24715., 26080.,
      24940., 26320., 18608., 19700., 18776., 19880., 18944., 20060., 19112.,
      20240.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1292., 1442., 1328., 1484., 1364., 1526., 1400., 1568., 1436., 1610.,
      1472., 1652., 1508., 1694., 1544., 1736., 1580., 1778., 1616., 1820.,
      2012., 2282., 2048., 2324., 2084., 2366., 2120., 2408., 2156., 2450.,
      2192., 2492., 2228., 2534., 2264., 2576., 2300., 2618., 2336., 2660.,
      2732., 3122., 2768., 3164., 2804., 3206., 2840., 3248., 2876., 3290.,
      2912., 3332., 2948., 3374., 2984., 3416., 3020., 3458., 3056., 3500.,
      3452., 3962., 3488., 4004., 3524., 4046., 3560., 4088., 3596., 4130.,
      3632., 4172., 3668., 4214., 3704., 4256., 3740., 4298., 3776., 4340.,
      4172., 4802., 4208., 4844., 4244., 4886., 4280., 4928., 4316., 4970.,
      4352., 5012., 4388., 5054., 4424., 5096., 4460., 5138., 4496., 5180.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      36628., 37216., 37804., 38392., 37240., 37840., 38440., 39040., 44495.,
      45230., 45965., 46700., 45230., 45980., 46730., 47480., 45965., 46730.,
      47495., 48260., 46700., 47480., 48260., 49040., 35404., 36016., 36628.,
      37240., 35968., 36592., 37216., 37840., 36532., 37168., 37804., 38440.,
      37096., 37744., 38392., 39040., 48868., 49696., 50524., 51352., 49480.,
      50320., 51160., 52000., 59195., 60230., 61265., 62300., 59930., 60980.,
      62030., 63080., 60665., 61730., 62795., 63860., 61400., 62480., 63560.,
      64640., 46684., 47536., 48388., 49240., 47248., 48112., 48976., 49840.,
      47812., 48688., 49564., 50440., 48376., 49264., 50152., 51040., 61584.,
      62688., 63792., 64896., 62240., 63360., 64480., 65600., 74460., 75840.,
      77220., 78600., 75240., 76640., 78040., 79440., 76020., 77440., 78860.,
      80280., 76800., 78240., 79680., 81120., 58352., 59488., 60624., 61760.,
      58944., 60096., 61248., 62400., 59536., 60704., 61872., 63040., 60128.,
      61312., 62496., 63680., 32308., 33136., 33964., 34792., 32680., 33520.,
      34360., 35200., 38495., 39530., 40565., 41600., 38930., 39980., 41030.,
      42080., 39365., 40430., 41495., 42560., 39800., 40880., 41960., 43040.,
      29644., 30496., 31348., 32200., 29968., 30832., 31696., 32560., 30292.,
      31168., 32044., 32920., 30616., 31504., 32392., 33280., 39748., 40816.,
      41884., 42952., 40120., 41200., 42280., 43360., 47195., 48530., 49865.,
      51200., 47630., 48980., 50330., 51680., 48065., 49430., 50795., 52160.,
      48500., 49880., 51260., 52640., 36124., 37216., 38308., 39400., 36448.,
      37552., 38656., 39760., 36772., 37888., 39004., 40120., 37096., 38224.,
      39352., 40480.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2434., 2584., 2734.,  2884.,  2500., 2656., 2812.,  2968.,  2566.,
      2728., 2890., 3052.,  2632.,  2800., 2968., 3136.,  2698.,  2872.,
      3046., 3220., 2764.,  2944.,  3124., 3304., 2830.,  3016.,  3202.,
      3388., 2896., 3088.,  3280.,  3472., 2962., 3160.,  3358.,  3556.,
      3028., 3232., 3436.,  3640.,  3754., 4024., 4294.,  4564.,  3820.,
      4096., 4372., 4648.,  3886.,  4168., 4450., 4732.,  3952.,  4240.,
      4528., 4816., 4018.,  4312.,  4606., 4900., 4084.,  4384.,  4684.,
      4984., 4150., 4456.,  4762.,  5068., 4216., 4528.,  4840.,  5152.,
      4282., 4600., 4918.,  5236.,  4348., 4672., 4996.,  5320.,  5074.,
      5464., 5854., 6244.,  5140.,  5536., 5932., 6328.,  5206.,  5608.,
      6010., 6412., 5272.,  5680.,  6088., 6496., 5338.,  5752.,  6166.,
      6580., 5404., 5824.,  6244.,  6664., 5470., 5896.,  6322.,  6748.,
      5536., 5968., 6400.,  6832.,  5602., 6040., 6478.,  6916.,  5668.,
      6112., 6556., 7000.,  6394.,  6904., 7414., 7924.,  6460.,  6976.,
      7492., 8008., 6526.,  7048.,  7570., 8092., 6592.,  7120.,  7648.,
      8176., 6658., 7192.,  7726.,  8260., 6724., 7264.,  7804.,  8344.,
      6790., 7336., 7882.,  8428.,  6856., 7408., 7960.,  8512.,  6922.,
      7480., 8038., 8596.,  6988.,  7552., 8116., 8680.,  7714.,  8344.,
      8974., 9604., 7780.,  8416.,  9052., 9688., 7846.,  8488.,  9130.,
      9772., 7912., 8560.,  9208.,  9856., 7978., 8632.,  9286.,  9940.,
      8044., 8704., 9364.,  10024., 8110., 8776., 9442.,  10108., 8176.,
      8848., 9520., 10192., 8242.,  8920., 9598., 10276., 8308.,  8992.,
      9676., 10360.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19034., 19196., 19358., 19520., 23155., 23350., 23545., 23740., 23935.,
      24130., 24325., 24520., 18470., 18620., 18770., 18920., 19070., 19220.,
      19370., 19520., 25514., 25676., 25838., 26000., 30955., 31150., 31345.,
      31540., 31735., 31930., 32125., 32320., 24470., 24620., 24770., 24920.,
      25070., 25220., 25370., 25520., 32272., 32448., 32624., 32800., 39090.,
      39300., 39510., 39720., 39930., 40140., 40350., 40560., 30720., 30880.,
      31040., 31200., 31360., 31520., 31680., 31840., 17294., 17396., 17498.,
      17600., 20680., 20800., 20920., 21040., 21160., 21280., 21400., 21520.,
      16010., 16100., 16190., 16280., 16370., 16460., 16550., 16640., 21374.,
      21476., 21578., 21680., 25480., 25600., 25720., 25840., 25960., 26080.,
      26200., 26320., 19610., 19700., 19790., 19880., 19970., 20060., 20150.,
      20240.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1421., 1442., 1463., 1484., 1505., 1526., 1547., 1568., 1589., 1610.,
      1631., 1652., 1673., 1694., 1715., 1736., 1757., 1778., 1799., 1820.,
      2261., 2282., 2303., 2324., 2345., 2366., 2387., 2408., 2429., 2450.,
      2471., 2492., 2513., 2534., 2555., 2576., 2597., 2618., 2639., 2660.,
      3101., 3122., 3143., 3164., 3185., 3206., 3227., 3248., 3269., 3290.,
      3311., 3332., 3353., 3374., 3395., 3416., 3437., 3458., 3479., 3500.,
      3941., 3962., 3983., 4004., 4025., 4046., 4067., 4088., 4109., 4130.,
      4151., 4172., 4193., 4214., 4235., 4256., 4277., 4298., 4319., 4340.,
      4781., 4802., 4823., 4844., 4865., 4886., 4907., 4928., 4949., 4970.,
      4991., 5012., 5033., 5054., 5075., 5096., 5117., 5138., 5159., 5180.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      36904., 38068., 37216., 38392., 37528., 38716., 37840., 39040., 44855.,
      46310., 45230., 46700., 45605., 47090., 45980., 47480., 46355., 47870.,
      46730., 48260., 47105., 48650., 47480., 49040., 35728., 36940., 36016.,
      37240., 36304., 37540., 36592., 37840., 36880., 38140., 37168., 38440.,
      37456., 38740., 37744., 39040., 49384., 51028., 49696., 51352., 50008.,
      51676., 50320., 52000., 59855., 61910., 60230., 62300., 60605., 62690.,
      60980., 63080., 61355., 63470., 61730., 63860., 62105., 64250., 62480.,
      64640., 47248., 48940., 47536., 49240., 47824., 49540., 48112., 49840.,
      48400., 50140., 48688., 50440., 48976., 50740., 49264., 51040., 62352.,
      64544., 62688., 64896., 63024., 65248., 63360., 65600., 75440., 78180.,
      75840., 78600., 76240., 79020., 76640., 79440., 77040., 79860., 77440.,
      80280., 77840., 80700., 78240., 81120., 59184., 61440., 59488., 61760.,
      59792., 62080., 60096., 62400., 60400., 62720., 60704., 63040., 61008.,
      63360., 61312., 63680., 32944., 34588., 33136., 34792., 33328., 34996.,
      33520., 35200., 39305., 41360., 39530., 41600., 39755., 41840., 39980.,
      42080., 40205., 42320., 40430., 42560., 40655., 42800., 40880., 43040.,
      30328., 32020., 30496., 32200., 30664., 32380., 30832., 32560., 31000.,
      32740., 31168., 32920., 31336., 33100., 31504., 33280., 40624., 42748.,
      40816., 42952., 41008., 43156., 41200., 43360., 48305., 50960., 48530.,
      51200., 48755., 51440., 48980., 51680., 49205., 51920., 49430., 52160.,
      49655., 52400., 49880., 52640., 37048., 39220., 37216., 39400., 37384.,
      39580., 37552., 39760., 37720., 39940., 37888., 40120., 38056., 40300.,
      38224., 40480.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2548.,  2842., 2584.,  2884.,  2620.,  2926.,  2656.,  2968.,  2692.,
      3010.,  2728., 3052.,  2764.,  3094.,  2800.,  3136.,  2836.,  3178.,
      2872.,  3220., 2908.,  3262.,  2944.,  3304.,  2980.,  3346.,  3016.,
      3388.,  3052., 3430.,  3088.,  3472.,  3124.,  3514.,  3160.,  3556.,
      3196.,  3598., 3232.,  3640.,  3988.,  4522.,  4024.,  4564.,  4060.,
      4606.,  4096., 4648.,  4132.,  4690.,  4168.,  4732.,  4204.,  4774.,
      4240.,  4816., 4276.,  4858.,  4312.,  4900.,  4348.,  4942.,  4384.,
      4984.,  4420., 5026.,  4456.,  5068.,  4492.,  5110.,  4528.,  5152.,
      4564.,  5194., 4600.,  5236.,  4636.,  5278.,  4672.,  5320.,  5428.,
      6202.,  5464., 6244.,  5500.,  6286.,  5536.,  6328.,  5572.,  6370.,
      5608.,  6412., 5644.,  6454.,  5680.,  6496.,  5716.,  6538.,  5752.,
      6580.,  5788., 6622.,  5824.,  6664.,  5860.,  6706.,  5896.,  6748.,
      5932.,  6790., 5968.,  6832.,  6004.,  6874.,  6040.,  6916.,  6076.,
      6958.,  6112., 7000.,  6868.,  7882.,  6904.,  7924.,  6940.,  7966.,
      6976.,  8008., 7012.,  8050.,  7048.,  8092.,  7084.,  8134.,  7120.,
      8176.,  7156., 8218.,  7192.,  8260.,  7228.,  8302.,  7264.,  8344.,
      7300.,  8386., 7336.,  8428.,  7372.,  8470.,  7408.,  8512.,  7444.,
      8554.,  7480., 8596.,  7516.,  8638.,  7552.,  8680.,  8308.,  9562.,
      8344.,  9604., 8380.,  9646.,  8416.,  9688.,  8452.,  9730.,  8488.,
      9772.,  8524., 9814.,  8560.,  9856.,  8596.,  9898.,  8632.,  9940.,
      8668.,  9982., 8704.,  10024., 8740.,  10066., 8776.,  10108., 8812.,
      10150., 8848., 10192., 8884.,  10234., 8920.,  10276., 8956.,  10318.,
      8992.,  10360.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x7x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      72644.,  73808.,  74972.,  76136.,  73256.,  74432.,  75608.,  76784.,
      73868.,  75056.,  76244.,  77432.,  74480.,  75680.,  76880.,  78080.,
      88255.,  89710.,  91165.,  92620.,  88990.,  90460.,  91930.,  93400.,
      89725.,  91210.,  92695.,  94180.,  90460.,  91960.,  93460.,  94960.,
      91195.,  92710.,  94225.,  95740.,  91930.,  93460.,  94990.,  96520.,
      92665.,  94210.,  95755.,  97300.,  93400.,  94960.,  96520.,  98080.,
      70244.,  71456.,  72668.,  73880.,  70808.,  72032.,  73256.,  74480.,
      71372.,  72608.,  73844.,  75080.,  71936.,  73184.,  74432.,  75680.,
      72500.,  73760.,  75020.,  76280.,  73064.,  74336.,  75608.,  76880.,
      73628.,  74912.,  76196.,  77480.,  74192.,  75488.,  76784.,  78080.,
      97124.,  98768.,  100412., 102056., 97736.,  99392.,  101048., 102704.,
      98348.,  100016., 101684., 103352., 98960.,  100640., 102320., 104000.,
      117655., 119710., 121765., 123820., 118390., 120460., 122530., 124600.,
      119125., 121210., 123295., 125380., 119860., 121960., 124060., 126160.,
      120595., 122710., 124825., 126940., 121330., 123460., 125590., 127720.,
      122065., 124210., 126355., 128500., 122800., 124960., 127120., 129280.,
      92804.,  94496.,  96188.,  97880.,  93368.,  95072.,  96776.,  98480.,
      93932.,  95648.,  97364.,  99080.,  94496.,  96224.,  97952.,  99680.,
      95060.,  96800.,  98540.,  100280., 95624.,  97376.,  99128.,  100880.,
      96188.,  97952.,  99716.,  101480., 96752.,  98528.,  100304., 102080.,
      122512., 124704., 126896., 129088., 123168., 125376., 127584., 129792.,
      123824., 126048., 128272., 130496., 124480., 126720., 128960., 131200.,
      148140., 150880., 153620., 156360., 148920., 151680., 154440., 157200.,
      149700., 152480., 155260., 158040., 150480., 153280., 156080., 158880.,
      151260., 154080., 156900., 159720., 152040., 154880., 157720., 160560.,
      152820., 155680., 158540., 161400., 153600., 156480., 159360., 162240.,
      116112., 118368., 120624., 122880., 116704., 118976., 121248., 123520.,
      117296., 119584., 121872., 124160., 117888., 120192., 122496., 124800.,
      118480., 120800., 123120., 125440., 119072., 121408., 123744., 126080.,
      119664., 122016., 124368., 126720., 120256., 122624., 124992., 127360.,
      64244.,  65888.,  67532.,  69176.,  64616.,  66272.,  67928.,  69584.,
      64988.,  66656.,  68324.,  69992.,  65360.,  67040.,  68720.,  70400.,
      76555.,  78610.,  80665.,  82720.,  76990.,  79060.,  81130.,  83200.,
      77425.,  79510.,  81595.,  83680.,  77860.,  79960.,  82060.,  84160.,
      78295.,  80410.,  82525.,  84640.,  78730.,  80860.,  82990.,  85120.,
      79165.,  81310.,  83455.,  85600.,  79600.,  81760.,  83920.,  86080.,
      58964.,  60656.,  62348.,  64040.,  59288.,  60992.,  62696.,  64400.,
      59612.,  61328.,  63044.,  64760.,  59936.,  61664.,  63392.,  65120.,
      60260.,  62000.,  63740.,  65480.,  60584.,  62336.,  64088.,  65840.,
      60908.,  62672.,  64436.,  66200.,  61232.,  63008.,  64784.,  66560.,
      79124.,  81248.,  83372.,  85496.,  79496.,  81632.,  83768.,  85904.,
      79868.,  82016.,  84164.,  86312.,  80240.,  82400.,  84560.,  86720.,
      93955.,  96610.,  99265.,  101920., 94390.,  97060.,  99730.,  102400.,
      94825.,  97510.,  100195., 102880., 95260.,  97960.,  100660., 103360.,
      95695.,  98410.,  101125., 103840., 96130.,  98860.,  101590., 104320.,
      96565.,  99310.,  102055., 104800., 97000.,  99760.,  102520., 105280.,
      71924.,  74096.,  76268.,  78440.,  72248.,  74432.,  76616.,  78800.,
      72572.,  74768.,  76964.,  79160.,  72896.,  75104.,  77312.,  79520.,
      73220.,  75440.,  77660.,  79880.,  73544.,  75776.,  78008.,  80240.,
      73868.,  76112.,  78356.,  80600.,  74192.,  76448.,  78704.,  80960.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x7x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4802.,  5096.,  5390.,  5684.,  4868.,  5168.,  5468.,  5768.,  4934.,
      5240.,  5546.,  5852.,  5000.,  5312.,  5624.,  5936.,  5066.,  5384.,
      5702.,  6020.,  5132.,  5456.,  5780.,  6104.,  5198.,  5528.,  5858.,
      6188.,  5264.,  5600.,  5936.,  6272.,  5330.,  5672.,  6014.,  6356.,
      5396.,  5744.,  6092.,  6440.,  5462.,  5816.,  6170.,  6524.,  5528.,
      5888.,  6248.,  6608.,  5594.,  5960.,  6326.,  6692.,  5660.,  6032.,
      6404.,  6776.,  5726.,  6104.,  6482.,  6860.,  5792.,  6176.,  6560.,
      6944.,  5858.,  6248.,  6638.,  7028.,  5924.,  6320.,  6716.,  7112.,
      5990.,  6392.,  6794.,  7196.,  6056.,  6464.,  6872.,  7280.,  7442.,
      7976.,  8510.,  9044.,  7508.,  8048.,  8588.,  9128.,  7574.,  8120.,
      8666.,  9212.,  7640.,  8192.,  8744.,  9296.,  7706.,  8264.,  8822.,
      9380.,  7772.,  8336.,  8900.,  9464.,  7838.,  8408.,  8978.,  9548.,
      7904.,  8480.,  9056.,  9632.,  7970.,  8552.,  9134.,  9716.,  8036.,
      8624.,  9212.,  9800.,  8102.,  8696.,  9290.,  9884.,  8168.,  8768.,
      9368.,  9968.,  8234.,  8840.,  9446.,  10052., 8300.,  8912.,  9524.,
      10136., 8366.,  8984.,  9602.,  10220., 8432.,  9056.,  9680.,  10304.,
      8498.,  9128.,  9758.,  10388., 8564.,  9200.,  9836.,  10472., 8630.,
      9272.,  9914.,  10556., 8696.,  9344.,  9992.,  10640., 10082., 10856.,
      11630., 12404., 10148., 10928., 11708., 12488., 10214., 11000., 11786.,
      12572., 10280., 11072., 11864., 12656., 10346., 11144., 11942., 12740.,
      10412., 11216., 12020., 12824., 10478., 11288., 12098., 12908., 10544.,
      11360., 12176., 12992., 10610., 11432., 12254., 13076., 10676., 11504.,
      12332., 13160., 10742., 11576., 12410., 13244., 10808., 11648., 12488.,
      13328., 10874., 11720., 12566., 13412., 10940., 11792., 12644., 13496.,
      11006., 11864., 12722., 13580., 11072., 11936., 12800., 13664., 11138.,
      12008., 12878., 13748., 11204., 12080., 12956., 13832., 11270., 12152.,
      13034., 13916., 11336., 12224., 13112., 14000., 12722., 13736., 14750.,
      15764., 12788., 13808., 14828., 15848., 12854., 13880., 14906., 15932.,
      12920., 13952., 14984., 16016., 12986., 14024., 15062., 16100., 13052.,
      14096., 15140., 16184., 13118., 14168., 15218., 16268., 13184., 14240.,
      15296., 16352., 13250., 14312., 15374., 16436., 13316., 14384., 15452.,
      16520., 13382., 14456., 15530., 16604., 13448., 14528., 15608., 16688.,
      13514., 14600., 15686., 16772., 13580., 14672., 15764., 16856., 13646.,
      14744., 15842., 16940., 13712., 14816., 15920., 17024., 13778., 14888.,
      15998., 17108., 13844., 14960., 16076., 17192., 13910., 15032., 16154.,
      17276., 13976., 15104., 16232., 17360., 15362., 16616., 17870., 19124.,
      15428., 16688., 17948., 19208., 15494., 16760., 18026., 19292., 15560.,
      16832., 18104., 19376., 15626., 16904., 18182., 19460., 15692., 16976.,
      18260., 19544., 15758., 17048., 18338., 19628., 15824., 17120., 18416.,
      19712., 15890., 17192., 18494., 19796., 15956., 17264., 18572., 19880.,
      16022., 17336., 18650., 19964., 16088., 17408., 18728., 20048., 16154.,
      17480., 18806., 20132., 16220., 17552., 18884., 20216., 16286., 17624.,
      18962., 20300., 16352., 17696., 19040., 20384., 16418., 17768., 19118.,
      20468., 16484., 17840., 19196., 20552., 16550., 17912., 19274., 20636.,
      16616., 17984., 19352., 20720.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2724., 2823., 3628., 2598., 2688., 3448., 3556., 4560., 3256.,
      3352., 4204., 4312., 5512., 3928., 4024., 2301., 2364., 2974.,
      2076., 2130., 2742., 2805., 3520., 2454., 2508.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120., 130., 140., 150., 160., 190., 200., 210., 220.,
      230., 260., 270., 280., 290., 300., 330., 340., 350.,
      360., 370., 400., 410., 420., 430., 440.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5232., 5448., 5421., 5646., 6956.,  7256.,  4971., 5196., 5142., 5376.,
      6608., 6896., 6812., 7112., 8720.,  9120.,  6212., 6512., 6392., 6704.,
      8036., 8408., 8240., 8624., 10512., 11024., 7472., 7856., 7652., 8048.,
      4323., 4602., 4440., 4728., 5564.,  5948.,  3864., 4152., 3963., 4260.,
      5142., 5484., 5259., 5610., 6572.,  7040.,  4557., 4908., 4656., 5016.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204., 240., 220., 260., 236., 280., 252., 300., 268., 320.,
      316., 380., 332., 400., 348., 420., 364., 440., 380., 460.,
      428., 520., 444., 540., 460., 560., 476., 580., 492., 600.,
      540., 660., 556., 680., 572., 700., 588., 720., 604., 740.,
      652., 800., 668., 820., 684., 840., 700., 860., 716., 880.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10248., 10464., 10680., 10896., 10617., 10842., 11067., 11292., 13612.,
      13912., 14212., 14512., 9717.,  9942.,  10167., 10392., 10050., 10284.,
      10518., 10752., 12928., 13216., 13504., 13792., 13324., 13624., 13924.,
      14224., 17040., 17440., 17840., 18240., 12124., 12424., 12724., 13024.,
      12472., 12784., 13096., 13408., 15700., 16072., 16444., 16816., 16096.,
      16480., 16864., 17248., 20512., 21024., 21536., 22048., 14560., 14944.,
      15328., 15712., 14908., 15304., 15700., 16096., 8367.,  8646.,  8925.,
      9204.,  8592.,  8880.,  9168.,  9456.,  10744., 11128., 11512., 11896.,
      7440.,  7728.,  8016.,  8304.,  7629.,  7926.,  8223.,  8520.,  9942.,
      10284., 10626., 10968., 10167., 10518., 10869., 11220., 12676., 13144.,
      13612., 14080., 8763.,  9114.,  9465.,  9816.,  8952.,  9312.,  9672.,
      10032.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      372.,  408.,  444.,  480.,  400.,  440.,  480.,  520.,  428.,  472.,
      516.,  560.,  456.,  504.,  552.,  600.,  484.,  536.,  588.,  640.,
      568.,  632.,  696.,  760.,  596.,  664.,  732.,  800.,  624.,  696.,
      768.,  840.,  652.,  728.,  804.,  880.,  680.,  760.,  840.,  920.,
      764.,  856.,  948.,  1040., 792.,  888.,  984.,  1080., 820.,  920.,
      1020., 1120., 848.,  952.,  1056., 1160., 876.,  984.,  1092., 1200.,
      960.,  1080., 1200., 1320., 988.,  1112., 1236., 1360., 1016., 1144.,
      1272., 1400., 1044., 1176., 1308., 1440., 1072., 1208., 1344., 1480.,
      1156., 1304., 1452., 1600., 1184., 1336., 1488., 1640., 1212., 1368.,
      1524., 1680., 1240., 1400., 1560., 1720., 1268., 1432., 1596., 1760.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5349., 5448., 5547., 5646., 7130.,  7256.,  5106., 5196., 5286., 5376.,
      6788., 6896., 7004., 7112., 8984.,  9120.,  6416., 6512., 6608., 6704.,
      8300., 8408., 8516., 8624., 10888., 11024., 7760., 7856., 7952., 8048.,
      4539., 4602., 4665., 4728., 5870.,  5948.,  4098., 4152., 4206., 4260.,
      5421., 5484., 5547., 5610., 6962.,  7040.,  4854., 4908., 4962., 5016.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      230., 240., 250., 260., 270., 280., 290., 300., 310., 320.,
      370., 380., 390., 400., 410., 420., 430., 440., 450., 460.,
      510., 520., 530., 540., 550., 560., 570., 580., 590., 600.,
      650., 660., 670., 680., 690., 700., 710., 720., 730., 740.,
      790., 800., 810., 820., 830., 840., 850., 860., 870., 880.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10275., 10698., 10464., 10896., 10653., 11094., 10842., 11292., 13672.,
      14260., 13912., 14512., 9771.,  10212., 9942.,  10392., 10113., 10572.,
      10284., 10752., 13012., 13576., 13216., 13792., 13420., 14008., 13624.,
      14224., 17184., 17968., 17440., 18240., 12244., 12832., 12424., 13024.,
      12604., 13216., 12784., 13408., 15868., 16600., 16072., 16816., 16276.,
      17032., 16480., 17248., 20768., 21776., 21024., 22048., 14764., 15520.,
      14944., 15712., 15124., 15904., 15304., 16096., 8529.,  9078.,  8646.,
      9204.,  8763.,  9330.,  8880.,  9456.,  10984., 11740., 11128., 11896.,
      7629.,  8196.,  7728.,  8304.,  7827.,  8412.,  7926.,  8520.,  10167.,
      10842., 10284., 10968., 10401., 11094., 10518., 11220., 13000., 13924.,
      13144., 14080., 9015.,  9708.,  9114.,  9816.,  9213.,  9924.,  9312.,
      10032.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      392.,  460.,  408.,  480.,  424.,  500.,  440.,  520.,  456.,  540.,
      472.,  560.,  488.,  580.,  504.,  600.,  520.,  620.,  536.,  640.,
      616.,  740.,  632.,  760.,  648.,  780.,  664.,  800.,  680.,  820.,
      696.,  840.,  712.,  860.,  728.,  880.,  744.,  900.,  760.,  920.,
      840.,  1020., 856.,  1040., 872.,  1060., 888.,  1080., 904.,  1100.,
      920.,  1120., 936.,  1140., 952.,  1160., 968.,  1180., 984.,  1200.,
      1064., 1300., 1080., 1320., 1096., 1340., 1112., 1360., 1128., 1380.,
      1144., 1400., 1160., 1420., 1176., 1440., 1192., 1460., 1208., 1480.,
      1288., 1580., 1304., 1600., 1320., 1620., 1336., 1640., 1352., 1660.,
      1368., 1680., 1384., 1700., 1400., 1720., 1416., 1740., 1432., 1760.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20127., 20550., 20973., 21396., 20496., 20928., 21360., 21792., 20865.,
      21306., 21747., 22188., 21234., 21684., 22134., 22584., 26756., 27344.,
      27932., 28520., 27224., 27824., 28424., 29024., 19101., 19542., 19983.,
      20424., 19434., 19884., 20334., 20784., 19767., 20226., 20685., 21144.,
      20100., 20568., 21036., 21504., 25460., 26024., 26588., 27152., 25856.,
      26432., 27008., 27584., 26252., 26840., 27428., 28016., 26648., 27248.,
      27848., 28448., 33584., 34368., 35152., 35936., 34080., 34880., 35680.,
      36480., 23900., 24488., 25076., 25664., 24248., 24848., 25448., 26048.,
      24596., 25208., 25820., 26432., 24944., 25568., 26192., 26816., 31004.,
      31736., 32468., 33200., 31400., 32144., 32888., 33632., 31796., 32552.,
      33308., 34064., 32192., 32960., 33728., 34496., 40528., 41536., 42544.,
      43552., 41024., 42048., 43072., 44096., 28772., 29528., 30284., 31040.,
      29120., 29888., 30656., 31424., 29468., 30248., 31028., 31808., 29816.,
      30608., 31400., 32192., 16509., 17058., 17607., 18156., 16734., 17292.,
      17850., 18408., 16959., 17526., 18093., 18660., 17184., 17760., 18336.,
      18912., 21212., 21968., 22724., 23480., 21488., 22256., 23024., 23792.,
      14691., 15258., 15825., 16392., 14880., 15456., 16032., 16608., 15069.,
      15654., 16239., 16824., 15258., 15852., 16446., 17040., 19659., 20334.,
      21009., 21684., 19884., 20568., 21252., 21936., 20109., 20802., 21495.,
      22188., 20334., 21036., 21738., 22440., 25076., 26000., 26924., 27848.,
      25352., 26288., 27224., 28160., 17337., 18030., 18723., 19416., 17526.,
      18228., 18930., 19632., 17715., 18426., 19137., 19848., 17904., 18624.,
      19344., 20064.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      716.,  784.,  852.,  920.,  744.,  816.,  888.,  960.,  772.,  848.,
      924.,  1000., 800.,  880.,  960.,  1040., 828.,  912.,  996.,  1080.,
      856.,  944.,  1032., 1120., 884.,  976.,  1068., 1160., 912.,  1008.,
      1104., 1200., 940.,  1040., 1140., 1240., 968.,  1072., 1176., 1280.,
      1108., 1232., 1356., 1480., 1136., 1264., 1392., 1520., 1164., 1296.,
      1428., 1560., 1192., 1328., 1464., 1600., 1220., 1360., 1500., 1640.,
      1248., 1392., 1536., 1680., 1276., 1424., 1572., 1720., 1304., 1456.,
      1608., 1760., 1332., 1488., 1644., 1800., 1360., 1520., 1680., 1840.,
      1500., 1680., 1860., 2040., 1528., 1712., 1896., 2080., 1556., 1744.,
      1932., 2120., 1584., 1776., 1968., 2160., 1612., 1808., 2004., 2200.,
      1640., 1840., 2040., 2240., 1668., 1872., 2076., 2280., 1696., 1904.,
      2112., 2320., 1724., 1936., 2148., 2360., 1752., 1968., 2184., 2400.,
      1892., 2128., 2364., 2600., 1920., 2160., 2400., 2640., 1948., 2192.,
      2436., 2680., 1976., 2224., 2472., 2720., 2004., 2256., 2508., 2760.,
      2032., 2288., 2544., 2800., 2060., 2320., 2580., 2840., 2088., 2352.,
      2616., 2880., 2116., 2384., 2652., 2920., 2144., 2416., 2688., 2960.,
      2284., 2576., 2868., 3160., 2312., 2608., 2904., 3200., 2340., 2640.,
      2940., 3240., 2368., 2672., 2976., 3280., 2396., 2704., 3012., 3320.,
      2424., 2736., 3048., 3360., 2452., 2768., 3084., 3400., 2480., 2800.,
      3120., 3440., 2508., 2832., 3156., 3480., 2536., 2864., 3192., 3520.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10599., 10698., 10797., 10896., 10995., 11094., 11193., 11292., 14134.,
      14260., 14386., 14512., 10122., 10212., 10302., 10392., 10482., 10572.,
      10662., 10752., 13468., 13576., 13684., 13792., 13900., 14008., 14116.,
      14224., 17832., 17968., 18104., 18240., 12736., 12832., 12928., 13024.,
      13120., 13216., 13312., 13408., 16492., 16600., 16708., 16816., 16924.,
      17032., 17140., 17248., 21640., 21776., 21912., 22048., 15424., 15520.,
      15616., 15712., 15808., 15904., 16000., 16096., 9015.,  9078.,  9141.,
      9204.,  9267.,  9330.,  9393.,  9456.,  11662., 11740., 11818., 11896.,
      8142.,  8196.,  8250.,  8304.,  8358.,  8412.,  8466.,  8520.,  10779.,
      10842., 10905., 10968., 11031., 11094., 11157., 11220., 13846., 13924.,
      14002., 14080., 9654.,  9708.,  9762.,  9816.,  9870.,  9924.,  9978.,
      10032.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      450.,  460.,  470.,  480.,  490.,  500.,  510.,  520.,  530.,  540.,
      550.,  560.,  570.,  580.,  590.,  600.,  610.,  620.,  630.,  640.,
      730.,  740.,  750.,  760.,  770.,  780.,  790.,  800.,  810.,  820.,
      830.,  840.,  850.,  860.,  870.,  880.,  890.,  900.,  910.,  920.,
      1010., 1020., 1030., 1040., 1050., 1060., 1070., 1080., 1090., 1100.,
      1110., 1120., 1130., 1140., 1150., 1160., 1170., 1180., 1190., 1200.,
      1290., 1300., 1310., 1320., 1330., 1340., 1350., 1360., 1370., 1380.,
      1390., 1400., 1410., 1420., 1430., 1440., 1450., 1460., 1470., 1480.,
      1570., 1580., 1590., 1600., 1610., 1620., 1630., 1640., 1650., 1660.,
      1670., 1680., 1690., 1700., 1710., 1720., 1730., 1740., 1750., 1760.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20361., 21198., 20550., 21396., 20739., 21594., 20928., 21792., 21117.,
      21990., 21306., 22188., 21495., 22386., 21684., 22584., 27104., 28268.,
      27344., 28520., 27584., 28772., 27824., 29024., 19371., 20244., 19542.,
      20424., 19713., 20604., 19884., 20784., 20055., 20964., 20226., 21144.,
      20397., 21324., 20568., 21504., 25820., 26936., 26024., 27152., 26228.,
      27368., 26432., 27584., 26636., 27800., 26840., 28016., 27044., 28232.,
      27248., 28448., 34112., 35664., 34368., 35936., 34624., 36208., 34880.,
      36480., 24308., 25472., 24488., 25664., 24668., 25856., 24848., 26048.,
      25028., 26240., 25208., 26432., 25388., 26624., 25568., 26816., 31532.,
      32984., 31736., 33200., 31940., 33416., 32144., 33632., 32348., 33848.,
      32552., 34064., 32756., 34280., 32960., 34496., 41280., 43280., 41536.,
      43552., 41792., 43824., 42048., 44096., 29348., 30848., 29528., 31040.,
      29708., 31232., 29888., 31424., 30068., 31616., 30248., 31808., 30428.,
      32000., 30608., 32192., 16941., 18030., 17058., 18156., 17175., 18282.,
      17292., 18408., 17409., 18534., 17526., 18660., 17643., 18786., 17760.,
      18912., 21824., 23324., 21968., 23480., 22112., 23636., 22256., 23792.,
      15159., 16284., 15258., 16392., 15357., 16500., 15456., 16608., 15555.,
      16716., 15654., 16824., 15753., 16932., 15852., 17040., 20217., 21558.,
      20334., 21684., 20451., 21810., 20568., 21936., 20685., 22062., 20802.,
      22188., 20919., 22314., 21036., 22440., 25856., 27692., 26000., 27848.,
      26144., 28004., 26288., 28160., 17931., 19308., 18030., 19416., 18129.,
      19524., 18228., 19632., 18327., 19740., 18426., 19848., 18525., 19956.,
      18624., 20064.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      768.,  900.,  784.,  920.,  800.,  940.,  816.,  960.,  832.,  980.,
      848.,  1000., 864.,  1020., 880.,  1040., 896.,  1060., 912.,  1080.,
      928.,  1100., 944.,  1120., 960.,  1140., 976.,  1160., 992.,  1180.,
      1008., 1200., 1024., 1220., 1040., 1240., 1056., 1260., 1072., 1280.,
      1216., 1460., 1232., 1480., 1248., 1500., 1264., 1520., 1280., 1540.,
      1296., 1560., 1312., 1580., 1328., 1600., 1344., 1620., 1360., 1640.,
      1376., 1660., 1392., 1680., 1408., 1700., 1424., 1720., 1440., 1740.,
      1456., 1760., 1472., 1780., 1488., 1800., 1504., 1820., 1520., 1840.,
      1664., 2020., 1680., 2040., 1696., 2060., 1712., 2080., 1728., 2100.,
      1744., 2120., 1760., 2140., 1776., 2160., 1792., 2180., 1808., 2200.,
      1824., 2220., 1840., 2240., 1856., 2260., 1872., 2280., 1888., 2300.,
      1904., 2320., 1920., 2340., 1936., 2360., 1952., 2380., 1968., 2400.,
      2112., 2580., 2128., 2600., 2144., 2620., 2160., 2640., 2176., 2660.,
      2192., 2680., 2208., 2700., 2224., 2720., 2240., 2740., 2256., 2760.,
      2272., 2780., 2288., 2800., 2304., 2820., 2320., 2840., 2336., 2860.,
      2352., 2880., 2368., 2900., 2384., 2920., 2400., 2940., 2416., 2960.,
      2560., 3140., 2576., 3160., 2592., 3180., 2608., 3200., 2624., 3220.,
      2640., 3240., 2656., 3260., 2672., 3280., 2688., 3300., 2704., 3320.,
      2720., 3340., 2736., 3360., 2752., 3380., 2768., 3400., 2784., 3420.,
      2800., 3440., 2816., 3460., 2832., 3480., 2848., 3500., 2864., 3520.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39885., 40722., 41559., 42396., 40254., 41100., 41946., 42792., 40623.,
      41478., 42333., 43188., 40992., 41856., 42720., 43584., 41361., 42234.,
      43107., 43980., 41730., 42612., 43494., 44376., 42099., 42990., 43881.,
      44772., 42468., 43368., 44268., 45168., 53044., 54208., 55372., 56536.,
      53512., 54688., 55864., 57040., 53980., 55168., 56356., 57544., 54448.,
      55648., 56848., 58048., 37869., 38742., 39615., 40488., 38202., 39084.,
      39966., 40848., 38535., 39426., 40317., 41208., 38868., 39768., 40668.,
      41568., 39201., 40110., 41019., 41928., 39534., 40452., 41370., 42288.,
      39867., 40794., 41721., 42648., 40200., 41136., 42072., 43008., 50524.,
      51640., 52756., 53872., 50920., 52048., 53176., 54304., 51316., 52456.,
      53596., 54736., 51712., 52864., 54016., 55168., 52108., 53272., 54436.,
      55600., 52504., 53680., 54856., 56032., 52900., 54088., 55276., 56464.,
      53296., 54496., 55696., 56896., 66672., 68224., 69776., 71328., 67168.,
      68736., 70304., 71872., 67664., 69248., 70832., 72416., 68160., 69760.,
      71360., 72960., 47452., 48616., 49780., 50944., 47800., 48976., 50152.,
      51328., 48148., 49336., 50524., 51712., 48496., 49696., 50896., 52096.,
      48844., 50056., 51268., 52480., 49192., 50416., 51640., 52864., 49540.,
      50776., 52012., 53248., 49888., 51136., 52384., 53632., 61612., 63064.,
      64516., 65968., 62008., 63472., 64936., 66400., 62404., 63880., 65356.,
      66832., 62800., 64288., 65776., 67264., 63196., 64696., 66196., 67696.,
      63592., 65104., 66616., 68128., 63988., 65512., 67036., 68560., 64384.,
      65920., 67456., 68992., 80560., 82560., 84560., 86560., 81056., 83072.,
      85088., 87104., 81552., 83584., 85616., 87648., 82048., 84096., 86144.,
      88192., 57196., 58696., 60196., 61696., 57544., 59056., 60568., 62080.,
      57892., 59416., 60940., 62464., 58240., 59776., 61312., 62848., 58588.,
      60136., 61684., 63232., 58936., 60496., 62056., 63616., 59284., 60856.,
      62428., 64000., 59632., 61216., 62800., 64384., 32793., 33882., 34971.,
      36060., 33018., 34116., 35214., 36312., 33243., 34350., 35457., 36564.,
      33468., 34584., 35700., 36816., 33693., 34818., 35943., 37068., 33918.,
      35052., 36186., 37320., 34143., 35286., 36429., 37572., 34368., 35520.,
      36672., 37824., 42148., 43648., 45148., 46648., 42424., 43936., 45448.,
      46960., 42700., 44224., 45748., 47272., 42976., 44512., 46048., 47584.,
      29193., 30318., 31443., 32568., 29382., 30516., 31650., 32784., 29571.,
      30714., 31857., 33000., 29760., 30912., 32064., 33216., 29949., 31110.,
      32271., 33432., 30138., 31308., 32478., 33648., 30327., 31506., 32685.,
      33864., 30516., 31704., 32892., 34080., 39093., 40434., 41775., 43116.,
      39318., 40668., 42018., 43368., 39543., 40902., 42261., 43620., 39768.,
      41136., 42504., 43872., 39993., 41370., 42747., 44124., 40218., 41604.,
      42990., 44376., 40443., 41838., 43233., 44628., 40668., 42072., 43476.,
      44880., 49876., 51712., 53548., 55384., 50152., 52000., 53848., 55696.,
      50428., 52288., 54148., 56008., 50704., 52576., 54448., 56320., 34485.,
      35862., 37239., 38616., 34674., 36060., 37446., 38832., 34863., 36258.,
      37653., 39048., 35052., 36456., 37860., 39264., 35241., 36654., 38067.,
      39480., 35430., 36852., 38274., 39696., 35619., 37050., 38481., 39912.,
      35808., 37248., 38688., 40128.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1404., 1536., 1668., 1800., 1432., 1568., 1704., 1840., 1460., 1600.,
      1740., 1880., 1488., 1632., 1776., 1920., 1516., 1664., 1812., 1960.,
      1544., 1696., 1848., 2000., 1572., 1728., 1884., 2040., 1600., 1760.,
      1920., 2080., 1628., 1792., 1956., 2120., 1656., 1824., 1992., 2160.,
      1684., 1856., 2028., 2200., 1712., 1888., 2064., 2240., 1740., 1920.,
      2100., 2280., 1768., 1952., 2136., 2320., 1796., 1984., 2172., 2360.,
      1824., 2016., 2208., 2400., 1852., 2048., 2244., 2440., 1880., 2080.,
      2280., 2480., 1908., 2112., 2316., 2520., 1936., 2144., 2352., 2560.,
      2188., 2432., 2676., 2920., 2216., 2464., 2712., 2960., 2244., 2496.,
      2748., 3000., 2272., 2528., 2784., 3040., 2300., 2560., 2820., 3080.,
      2328., 2592., 2856., 3120., 2356., 2624., 2892., 3160., 2384., 2656.,
      2928., 3200., 2412., 2688., 2964., 3240., 2440., 2720., 3000., 3280.,
      2468., 2752., 3036., 3320., 2496., 2784., 3072., 3360., 2524., 2816.,
      3108., 3400., 2552., 2848., 3144., 3440., 2580., 2880., 3180., 3480.,
      2608., 2912., 3216., 3520., 2636., 2944., 3252., 3560., 2664., 2976.,
      3288., 3600., 2692., 3008., 3324., 3640., 2720., 3040., 3360., 3680.,
      2972., 3328., 3684., 4040., 3000., 3360., 3720., 4080., 3028., 3392.,
      3756., 4120., 3056., 3424., 3792., 4160., 3084., 3456., 3828., 4200.,
      3112., 3488., 3864., 4240., 3140., 3520., 3900., 4280., 3168., 3552.,
      3936., 4320., 3196., 3584., 3972., 4360., 3224., 3616., 4008., 4400.,
      3252., 3648., 4044., 4440., 3280., 3680., 4080., 4480., 3308., 3712.,
      4116., 4520., 3336., 3744., 4152., 4560., 3364., 3776., 4188., 4600.,
      3392., 3808., 4224., 4640., 3420., 3840., 4260., 4680., 3448., 3872.,
      4296., 4720., 3476., 3904., 4332., 4760., 3504., 3936., 4368., 4800.,
      3756., 4224., 4692., 5160., 3784., 4256., 4728., 5200., 3812., 4288.,
      4764., 5240., 3840., 4320., 4800., 5280., 3868., 4352., 4836., 5320.,
      3896., 4384., 4872., 5360., 3924., 4416., 4908., 5400., 3952., 4448.,
      4944., 5440., 3980., 4480., 4980., 5480., 4008., 4512., 5016., 5520.,
      4036., 4544., 5052., 5560., 4064., 4576., 5088., 5600., 4092., 4608.,
      5124., 5640., 4120., 4640., 5160., 5680., 4148., 4672., 5196., 5720.,
      4176., 4704., 5232., 5760., 4204., 4736., 5268., 5800., 4232., 4768.,
      5304., 5840., 4260., 4800., 5340., 5880., 4288., 4832., 5376., 5920.,
      4540., 5120., 5700., 6280., 4568., 5152., 5736., 6320., 4596., 5184.,
      5772., 6360., 4624., 5216., 5808., 6400., 4652., 5248., 5844., 6440.,
      4680., 5280., 5880., 6480., 4708., 5312., 5916., 6520., 4736., 5344.,
      5952., 6560., 4764., 5376., 5988., 6600., 4792., 5408., 6024., 6640.,
      4820., 5440., 6060., 6680., 4848., 5472., 6096., 6720., 4876., 5504.,
      6132., 6760., 4904., 5536., 6168., 6800., 4932., 5568., 6204., 6840.,
      4960., 5600., 6240., 6880., 4988., 5632., 6276., 6920., 5016., 5664.,
      6312., 6960., 5044., 5696., 6348., 7000., 5072., 5728., 6384., 7040.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3168., 4070., 4196., 3006., 3096., 4000., 5128., 5264., 3760.,
      3856., 4864., 6216., 6352., 4528., 4624., 2664., 3350., 3428.,
      2394., 2448., 3168., 3974., 4052., 2826., 2880.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      134., 144., 154., 164., 174., 214., 224., 234., 244.,
      254., 294., 304., 314., 324., 334., 374., 384., 394.,
      404., 414., 454., 464., 474., 484., 494.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6084., 6336., 7804.,  8140.,  8044.,  8392.,  5751., 6012., 5922., 6192.,
      7664., 8000., 9808.,  10256., 10064., 10528., 7172., 7520., 7352., 7712.,
      9296., 9728., 11856., 12432., 12112., 12704., 8612., 9056., 8792., 9248.,
      5004., 5328., 6268.,  6700.,  6412.,  6856.,  4455., 4788., 4554., 4896.,
      5940., 6336., 7420.,  7948.,  7564.,  8104.,  5247., 5652., 5346., 5760.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      228., 268., 244., 288., 260., 308., 276., 328., 292., 348.,
      356., 428., 372., 448., 388., 468., 404., 488., 420., 508.,
      484., 588., 500., 608., 516., 628., 532., 648., 548., 668.,
      612., 748., 628., 768., 644., 788., 660., 808., 676., 828.,
      740., 908., 756., 928., 772., 948., 788., 968., 804., 988.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11916., 12168., 12420., 12672., 15272., 15608., 15944., 16280., 15740.,
      16088., 16436., 16784., 11241., 11502., 11763., 12024., 11574., 11844.,
      12114., 12384., 14992., 15328., 15664., 16000., 19168., 19616., 20064.,
      20512., 19664., 20128., 20592., 21056., 13996., 14344., 14692., 15040.,
      14344., 14704., 15064., 15424., 18160., 18592., 19024., 19456., 23136.,
      23712., 24288., 24864., 23632., 24224., 24816., 25408., 16780., 17224.,
      17668., 18112., 17128., 17584., 18040., 18496., 9684.,  10008., 10332.,
      10656., 12104., 12536., 12968., 13400., 12380., 12824., 13268., 13712.,
      8577.,  8910.,  9243.,  9576.,  8766.,  9108.,  9450.,  9792.,  11484.,
      11880., 12276., 12672., 14312., 14840., 15368., 15896., 14588., 15128.,
      15668., 16208., 10089., 10494., 10899., 11304., 10278., 10692., 11106.,
      11520.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      416.,  456.,  496.,  536.,  444.,  488.,  532.,  576.,  472.,  520.,
      568.,  616.,  500.,  552.,  604.,  656.,  528.,  584.,  640.,  696.,
      640.,  712.,  784.,  856.,  668.,  744.,  820.,  896.,  696.,  776.,
      856.,  936.,  724.,  808.,  892.,  976.,  752.,  840.,  928.,  1016.,
      864.,  968.,  1072., 1176., 892.,  1000., 1108., 1216., 920.,  1032.,
      1144., 1256., 948.,  1064., 1180., 1296., 976.,  1096., 1216., 1336.,
      1088., 1224., 1360., 1496., 1116., 1256., 1396., 1536., 1144., 1288.,
      1432., 1576., 1172., 1320., 1468., 1616., 1200., 1352., 1504., 1656.,
      1312., 1480., 1648., 1816., 1340., 1512., 1684., 1856., 1368., 1544.,
      1720., 1896., 1396., 1576., 1756., 1936., 1424., 1608., 1792., 1976.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6237., 6336., 8014.,  8140.,  8266.,  8392.,  5922., 6012., 6102., 6192.,
      7892., 8000., 10120., 10256., 10392., 10528., 7424., 7520., 7616., 7712.,
      9620., 9728., 12296., 12432., 12568., 12704., 8960., 9056., 9152., 9248.,
      5265., 5328., 6622.,  6700.,  6778.,  6856.,  4734., 4788., 4842., 4896.,
      6273., 6336., 7870.,  7948.,  8026.,  8104.,  5598., 5652., 5706., 5760.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      258., 268., 278., 288., 298., 308., 318., 328., 338., 348.,
      418., 428., 438., 448., 458., 468., 478., 488., 498., 508.,
      578., 588., 598., 608., 618., 628., 638., 648., 658., 668.,
      738., 748., 758., 768., 778., 788., 798., 808., 818., 828.,
      898., 908., 918., 928., 938., 948., 958., 968., 978., 988.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11979., 12474., 12168., 12672., 15368., 16028., 15608., 16280., 15848.,
      16532., 16088., 16784., 11331., 11844., 11502., 12024., 11673., 12204.,
      11844., 12384., 15124., 15784., 15328., 16000., 19360., 20240., 19616.,
      20512., 19872., 20784., 20128., 21056., 14164., 14848., 14344., 15040.,
      14524., 15232., 14704., 15424., 18388., 19240., 18592., 19456., 23456.,
      24592., 23712., 24864., 23968., 25136., 24224., 25408., 17044., 17920.,
      17224., 18112., 17404., 18304., 17584., 18496., 9891.,  10530., 10008.,
      10656., 12392., 13244., 12536., 13400., 12680., 13556., 12824., 13712.,
      8811.,  9468.,  8910.,  9576.,  9009.,  9684.,  9108.,  9792.,  11763.,
      12546., 11880., 12672., 14696., 15740., 14840., 15896., 14984., 16052.,
      15128., 16208., 10395., 11196., 10494., 11304., 10593., 11412., 10692.,
      11520.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      440.,  516.,  456.,  536.,  472.,  556.,  488.,  576.,  504.,  596.,
      520.,  616.,  536.,  636.,  552.,  656.,  568.,  676.,  584.,  696.,
      696.,  836.,  712.,  856.,  728.,  876.,  744.,  896.,  760.,  916.,
      776.,  936.,  792.,  956.,  808.,  976.,  824.,  996.,  840.,  1016.,
      952.,  1156., 968.,  1176., 984.,  1196., 1000., 1216., 1016., 1236.,
      1032., 1256., 1048., 1276., 1064., 1296., 1080., 1316., 1096., 1336.,
      1208., 1476., 1224., 1496., 1240., 1516., 1256., 1536., 1272., 1556.,
      1288., 1576., 1304., 1596., 1320., 1616., 1336., 1636., 1352., 1656.,
      1464., 1796., 1480., 1816., 1496., 1836., 1512., 1856., 1528., 1876.,
      1544., 1896., 1560., 1916., 1576., 1936., 1592., 1956., 1608., 1976.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23463., 23958., 24453., 24948., 23832., 24336., 24840., 25344., 30076.,
      30736., 31396., 32056., 30544., 31216., 31888., 32560., 31012., 31696.,
      32380., 33064., 31480., 32176., 32872., 33568., 22149., 22662., 23175.,
      23688., 22482., 23004., 23526., 24048., 22815., 23346., 23877., 24408.,
      23148., 23688., 24228., 24768., 29588., 30248., 30908., 31568., 29984.,
      30656., 31328., 32000., 37840., 38720., 39600., 40480., 38336., 39232.,
      40128., 41024., 38832., 39744., 40656., 41568., 39328., 40256., 41184.,
      42112., 27644., 28328., 29012., 29696., 27992., 28688., 29384., 30080.,
      28340., 29048., 29756., 30464., 28688., 29408., 30128., 30848., 35924.,
      36776., 37628., 38480., 36320., 37184., 38048., 38912., 45776., 46912.,
      48048., 49184., 46272., 47424., 48576., 49728., 46768., 47936., 49104.,
      50272., 47264., 48448., 49632., 50816., 33212., 34088., 34964., 35840.,
      33560., 34448., 35336., 36224., 33908., 34808., 35708., 36608., 34256.,
      35168., 36080., 36992., 19143., 19782., 20421., 21060., 19368., 20016.,
      20664., 21312., 23932., 24784., 25636., 26488., 24208., 25072., 25936.,
      26800., 24484., 25360., 26236., 27112., 24760., 25648., 26536., 27424.,
      16965., 17622., 18279., 18936., 17154., 17820., 18486., 19152., 17343.,
      18018., 18693., 19368., 17532., 18216., 18900., 19584., 22743., 23526.,
      24309., 25092., 22968., 23760., 24552., 25344., 28348., 29392., 30436.,
      31480., 28624., 29680., 30736., 31792., 28900., 29968., 31036., 32104.,
      29176., 30256., 31336., 32416., 19989., 20790., 21591., 22392., 20178.,
      20988., 21798., 22608., 20367., 21186., 22005., 22824., 20556., 21384.,
      22212., 23040.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      804.,  880.,  956.,  1032., 832.,  912.,  992.,  1072., 860.,  944.,
      1028., 1112., 888.,  976.,  1064., 1152., 916.,  1008., 1100., 1192.,
      944.,  1040., 1136., 1232., 972.,  1072., 1172., 1272., 1000., 1104.,
      1208., 1312., 1028., 1136., 1244., 1352., 1056., 1168., 1280., 1392.,
      1252., 1392., 1532., 1672., 1280., 1424., 1568., 1712., 1308., 1456.,
      1604., 1752., 1336., 1488., 1640., 1792., 1364., 1520., 1676., 1832.,
      1392., 1552., 1712., 1872., 1420., 1584., 1748., 1912., 1448., 1616.,
      1784., 1952., 1476., 1648., 1820., 1992., 1504., 1680., 1856., 2032.,
      1700., 1904., 2108., 2312., 1728., 1936., 2144., 2352., 1756., 1968.,
      2180., 2392., 1784., 2000., 2216., 2432., 1812., 2032., 2252., 2472.,
      1840., 2064., 2288., 2512., 1868., 2096., 2324., 2552., 1896., 2128.,
      2360., 2592., 1924., 2160., 2396., 2632., 1952., 2192., 2432., 2672.,
      2148., 2416., 2684., 2952., 2176., 2448., 2720., 2992., 2204., 2480.,
      2756., 3032., 2232., 2512., 2792., 3072., 2260., 2544., 2828., 3112.,
      2288., 2576., 2864., 3152., 2316., 2608., 2900., 3192., 2344., 2640.,
      2936., 3232., 2372., 2672., 2972., 3272., 2400., 2704., 3008., 3312.,
      2596., 2928., 3260., 3592., 2624., 2960., 3296., 3632., 2652., 2992.,
      3332., 3672., 2680., 3024., 3368., 3712., 2708., 3056., 3404., 3752.,
      2736., 3088., 3440., 3792., 2764., 3120., 3476., 3832., 2792., 3152.,
      3512., 3872., 2820., 3184., 3548., 3912., 2848., 3216., 3584., 3952.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12375., 12474., 12573., 12672., 15902., 16028., 16154., 16280., 16406.,
      16532., 16658., 16784., 11754., 11844., 11934., 12024., 12114., 12204.,
      12294., 12384., 15676., 15784., 15892., 16000., 20104., 20240., 20376.,
      20512., 20648., 20784., 20920., 21056., 14752., 14848., 14944., 15040.,
      15136., 15232., 15328., 15424., 19132., 19240., 19348., 19456., 24456.,
      24592., 24728., 24864., 25000., 25136., 25272., 25408., 17824., 17920.,
      18016., 18112., 18208., 18304., 18400., 18496., 10467., 10530., 10593.,
      10656., 13166., 13244., 13322., 13400., 13478., 13556., 13634., 13712.,
      9414.,  9468.,  9522.,  9576.,  9630.,  9684.,  9738.,  9792.,  12483.,
      12546., 12609., 12672., 15662., 15740., 15818., 15896., 15974., 16052.,
      16130., 16208., 11142., 11196., 11250., 11304., 11358., 11412., 11466.,
      11520.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      506.,  516.,  526.,  536.,  546.,  556.,  566.,  576.,  586.,  596.,
      606.,  616.,  626.,  636.,  646.,  656.,  666.,  676.,  686.,  696.,
      826.,  836.,  846.,  856.,  866.,  876.,  886.,  896.,  906.,  916.,
      926.,  936.,  946.,  956.,  966.,  976.,  986.,  996.,  1006., 1016.,
      1146., 1156., 1166., 1176., 1186., 1196., 1206., 1216., 1226., 1236.,
      1246., 1256., 1266., 1276., 1286., 1296., 1306., 1316., 1326., 1336.,
      1466., 1476., 1486., 1496., 1506., 1516., 1526., 1536., 1546., 1556.,
      1566., 1576., 1586., 1596., 1606., 1616., 1626., 1636., 1646., 1656.,
      1786., 1796., 1806., 1816., 1826., 1836., 1846., 1856., 1866., 1876.,
      1886., 1896., 1906., 1916., 1926., 1936., 1946., 1956., 1966., 1976.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23769., 24750., 23958., 24948., 24147., 25146., 24336., 25344., 30496.,
      31804., 30736., 32056., 30976., 32308., 31216., 32560., 31456., 32812.,
      31696., 33064., 31936., 33316., 32176., 33568., 22491., 23508., 22662.,
      23688., 22833., 23868., 23004., 24048., 23175., 24228., 23346., 24408.,
      23517., 24588., 23688., 24768., 30044., 31352., 30248., 31568., 30452.,
      31784., 30656., 32000., 38464., 40208., 38720., 40480., 38976., 40752.,
      39232., 41024., 39488., 41296., 39744., 41568., 40000., 41840., 40256.,
      42112., 28148., 29504., 28328., 29696., 28508., 29888., 28688., 30080.,
      28868., 30272., 29048., 30464., 29228., 30656., 29408., 30848., 36572.,
      38264., 36776., 38480., 36980., 38696., 37184., 38912., 46656., 48912.,
      46912., 49184., 47168., 49456., 47424., 49728., 47680., 50000., 47936.,
      50272., 48192., 50544., 48448., 50816., 33908., 35648., 34088., 35840.,
      34268., 36032., 34448., 36224., 34628., 36416., 34808., 36608., 34988.,
      36800., 35168., 36992., 19665., 20934., 19782., 21060., 19899., 21186.,
      20016., 21312., 24640., 26332., 24784., 26488., 24928., 26644., 25072.,
      26800., 25216., 26956., 25360., 27112., 25504., 27268., 25648., 27424.,
      17523., 18828., 17622., 18936., 17721., 19044., 17820., 19152., 17919.,
      19260., 18018., 19368., 18117., 19476., 18216., 19584., 23409., 24966.,
      23526., 25092., 23643., 25218., 23760., 25344., 29248., 31324., 29392.,
      31480., 29536., 31636., 29680., 31792., 29824., 31948., 29968., 32104.,
      30112., 32260., 30256., 32416., 20691., 22284., 20790., 22392., 20889.,
      22500., 20988., 22608., 21087., 22716., 21186., 22824., 21285., 22932.,
      21384., 23040.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      864.,  1012., 880.,  1032., 896.,  1052., 912.,  1072., 928.,  1092.,
      944.,  1112., 960.,  1132., 976.,  1152., 992.,  1172., 1008., 1192.,
      1024., 1212., 1040., 1232., 1056., 1252., 1072., 1272., 1088., 1292.,
      1104., 1312., 1120., 1332., 1136., 1352., 1152., 1372., 1168., 1392.,
      1376., 1652., 1392., 1672., 1408., 1692., 1424., 1712., 1440., 1732.,
      1456., 1752., 1472., 1772., 1488., 1792., 1504., 1812., 1520., 1832.,
      1536., 1852., 1552., 1872., 1568., 1892., 1584., 1912., 1600., 1932.,
      1616., 1952., 1632., 1972., 1648., 1992., 1664., 2012., 1680., 2032.,
      1888., 2292., 1904., 2312., 1920., 2332., 1936., 2352., 1952., 2372.,
      1968., 2392., 1984., 2412., 2000., 2432., 2016., 2452., 2032., 2472.,
      2048., 2492., 2064., 2512., 2080., 2532., 2096., 2552., 2112., 2572.,
      2128., 2592., 2144., 2612., 2160., 2632., 2176., 2652., 2192., 2672.,
      2400., 2932., 2416., 2952., 2432., 2972., 2448., 2992., 2464., 3012.,
      2480., 3032., 2496., 3052., 2512., 3072., 2528., 3092., 2544., 3112.,
      2560., 3132., 2576., 3152., 2592., 3172., 2608., 3192., 2624., 3212.,
      2640., 3232., 2656., 3252., 2672., 3272., 2688., 3292., 2704., 3312.,
      2912., 3572., 2928., 3592., 2944., 3612., 2960., 3632., 2976., 3652.,
      2992., 3672., 3008., 3692., 3024., 3712., 3040., 3732., 3056., 3752.,
      3072., 3772., 3088., 3792., 3104., 3812., 3120., 3832., 3136., 3852.,
      3152., 3872., 3168., 3892., 3184., 3912., 3200., 3932., 3216., 3952.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46557., 47538., 48519., 49500.,  46926., 47916., 48906., 49896.,
      47295., 48294., 49293., 50292.,  47664., 48672., 49680., 50688.,
      59684., 60992., 62300., 63608.,  60152., 61472., 62792., 64112.,
      60620., 61952., 63284., 64616.,  61088., 62432., 63776., 65120.,
      61556., 62912., 64268., 65624.,  62024., 63392., 64760., 66128.,
      62492., 63872., 65252., 66632.,  62960., 64352., 65744., 67136.,
      43965., 44982., 45999., 47016.,  44298., 45324., 46350., 47376.,
      44631., 45666., 46701., 47736.,  44964., 46008., 47052., 48096.,
      45297., 46350., 47403., 48456.,  45630., 46692., 47754., 48816.,
      45963., 47034., 48105., 49176.,  46296., 47376., 48456., 49536.,
      58780., 60088., 61396., 62704.,  59176., 60496., 61816., 63136.,
      59572., 60904., 62236., 63568.,  59968., 61312., 62656., 64000.,
      75184., 76928., 78672., 80416.,  75680., 77440., 79200., 80960.,
      76176., 77952., 79728., 81504.,  76672., 78464., 80256., 82048.,
      77168., 78976., 80784., 82592.,  77664., 79488., 81312., 83136.,
      78160., 80000., 81840., 83680.,  78656., 80512., 82368., 84224.,
      54940., 56296., 57652., 59008.,  55288., 56656., 58024., 59392.,
      55636., 57016., 58396., 59776.,  55984., 57376., 58768., 60160.,
      56332., 57736., 59140., 60544.,  56680., 58096., 59512., 60928.,
      57028., 58456., 59884., 61312.,  57376., 58816., 60256., 61696.,
      71452., 73144., 74836., 76528.,  71848., 73552., 75256., 76960.,
      72244., 73960., 75676., 77392.,  72640., 74368., 76096., 77824.,
      91056., 93312., 95568., 97824.,  91552., 93824., 96096., 98368.,
      92048., 94336., 96624., 98912.,  92544., 94848., 97152., 99456.,
      93040., 95360., 97680., 100000., 93536., 95872., 98208., 100544.,
      94032., 96384., 98736., 101088., 94528., 96896., 99264., 101632.,
      66076., 67816., 69556., 71296.,  66424., 68176., 69928., 71680.,
      66772., 68536., 70300., 72064.,  67120., 68896., 70672., 72448.,
      67468., 69256., 71044., 72832.,  67816., 69616., 71416., 73216.,
      68164., 69976., 71788., 73600.,  68512., 70336., 72160., 73984.,
      38061., 39330., 40599., 41868.,  38286., 39564., 40842., 42120.,
      38511., 39798., 41085., 42372.,  38736., 40032., 41328., 42624.,
      47588., 49280., 50972., 52664.,  47864., 49568., 51272., 52976.,
      48140., 49856., 51572., 53288.,  48416., 50144., 51872., 53600.,
      48692., 50432., 52172., 53912.,  48968., 50720., 52472., 54224.,
      49244., 51008., 52772., 54536.,  49520., 51296., 53072., 54848.,
      33741., 35046., 36351., 37656.,  33930., 35244., 36558., 37872.,
      34119., 35442., 36765., 38088.,  34308., 35640., 36972., 38304.,
      34497., 35838., 37179., 38520.,  34686., 36036., 37386., 38736.,
      34875., 36234., 37593., 38952.,  35064., 36432., 37800., 39168.,
      45261., 46818., 48375., 49932.,  45486., 47052., 48618., 50184.,
      45711., 47286., 48861., 50436.,  45936., 47520., 49104., 50688.,
      56420., 58496., 60572., 62648.,  56696., 58784., 60872., 62960.,
      56972., 59072., 61172., 63272.,  57248., 59360., 61472., 63584.,
      57524., 59648., 61772., 63896.,  57800., 59936., 62072., 64208.,
      58076., 60224., 62372., 64520.,  58352., 60512., 62672., 64832.,
      39789., 41382., 42975., 44568.,  39978., 41580., 43182., 44784.,
      40167., 41778., 43389., 45000.,  40356., 41976., 43596., 45216.,
      40545., 42174., 43803., 45432.,  40734., 42372., 44010., 45648.,
      40923., 42570., 44217., 45864.,  41112., 42768., 44424., 46080.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1580., 1728., 1876., 2024., 1608., 1760., 1912., 2064., 1636., 1792.,
      1948., 2104., 1664., 1824., 1984., 2144., 1692., 1856., 2020., 2184.,
      1720., 1888., 2056., 2224., 1748., 1920., 2092., 2264., 1776., 1952.,
      2128., 2304., 1804., 1984., 2164., 2344., 1832., 2016., 2200., 2384.,
      1860., 2048., 2236., 2424., 1888., 2080., 2272., 2464., 1916., 2112.,
      2308., 2504., 1944., 2144., 2344., 2544., 1972., 2176., 2380., 2584.,
      2000., 2208., 2416., 2624., 2028., 2240., 2452., 2664., 2056., 2272.,
      2488., 2704., 2084., 2304., 2524., 2744., 2112., 2336., 2560., 2784.,
      2476., 2752., 3028., 3304., 2504., 2784., 3064., 3344., 2532., 2816.,
      3100., 3384., 2560., 2848., 3136., 3424., 2588., 2880., 3172., 3464.,
      2616., 2912., 3208., 3504., 2644., 2944., 3244., 3544., 2672., 2976.,
      3280., 3584., 2700., 3008., 3316., 3624., 2728., 3040., 3352., 3664.,
      2756., 3072., 3388., 3704., 2784., 3104., 3424., 3744., 2812., 3136.,
      3460., 3784., 2840., 3168., 3496., 3824., 2868., 3200., 3532., 3864.,
      2896., 3232., 3568., 3904., 2924., 3264., 3604., 3944., 2952., 3296.,
      3640., 3984., 2980., 3328., 3676., 4024., 3008., 3360., 3712., 4064.,
      3372., 3776., 4180., 4584., 3400., 3808., 4216., 4624., 3428., 3840.,
      4252., 4664., 3456., 3872., 4288., 4704., 3484., 3904., 4324., 4744.,
      3512., 3936., 4360., 4784., 3540., 3968., 4396., 4824., 3568., 4000.,
      4432., 4864., 3596., 4032., 4468., 4904., 3624., 4064., 4504., 4944.,
      3652., 4096., 4540., 4984., 3680., 4128., 4576., 5024., 3708., 4160.,
      4612., 5064., 3736., 4192., 4648., 5104., 3764., 4224., 4684., 5144.,
      3792., 4256., 4720., 5184., 3820., 4288., 4756., 5224., 3848., 4320.,
      4792., 5264., 3876., 4352., 4828., 5304., 3904., 4384., 4864., 5344.,
      4268., 4800., 5332., 5864., 4296., 4832., 5368., 5904., 4324., 4864.,
      5404., 5944., 4352., 4896., 5440., 5984., 4380., 4928., 5476., 6024.,
      4408., 4960., 5512., 6064., 4436., 4992., 5548., 6104., 4464., 5024.,
      5584., 6144., 4492., 5056., 5620., 6184., 4520., 5088., 5656., 6224.,
      4548., 5120., 5692., 6264., 4576., 5152., 5728., 6304., 4604., 5184.,
      5764., 6344., 4632., 5216., 5800., 6384., 4660., 5248., 5836., 6424.,
      4688., 5280., 5872., 6464., 4716., 5312., 5908., 6504., 4744., 5344.,
      5944., 6544., 4772., 5376., 5980., 6584., 4800., 5408., 6016., 6624.,
      5164., 5824., 6484., 7144., 5192., 5856., 6520., 7184., 5220., 5888.,
      6556., 7224., 5248., 5920., 6592., 7264., 5276., 5952., 6628., 7304.,
      5304., 5984., 6664., 7344., 5332., 6016., 6700., 7384., 5360., 6048.,
      6736., 7424., 5388., 6080., 6772., 7464., 5416., 6112., 6808., 7504.,
      5444., 6144., 6844., 7544., 5472., 6176., 6880., 7584., 5500., 6208.,
      6916., 7624., 5528., 6240., 6952., 7664., 5556., 6272., 6988., 7704.,
      5584., 6304., 7024., 7744., 5612., 6336., 7060., 7784., 5640., 6368.,
      7096., 7824., 5668., 6400., 7132., 7864., 5696., 6432., 7168., 7904.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6500., 7885., 8080.,  6230.,  6380., 8200., 9930., 10140., 7800.,
      7960., 9960., 12030., 12240., 9400., 9560., 5420., 6460.,  6580.,
      4970., 5060., 6440.,  7660.,  7780., 5870., 5960.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      371.,  392.,  413.,  434.,  455.,  581.,  602.,  623.,  644.,
      665.,  791.,  812.,  833.,  854.,  875.,  1001., 1022., 1043.,
      1064., 1085., 1211., 1232., 1253., 1274., 1295.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12580., 13000., 15245., 15770., 15620., 16160., 12028., 12460., 12316.,
      12760., 15840., 16400., 19160., 19860., 19560., 20280., 15024., 15600.,
      15328., 15920., 19200., 19920., 23160., 24060., 23560., 24480., 18064.,
      18800., 18368., 19120., 10300., 10840., 12245., 12920., 12470., 13160.,
      9388.,  9940.,  9556.,  10120., 12220., 12880., 14495., 15320., 14720.,
      15560., 11068., 11740., 11236., 11920.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      664.,  742.,  700.,  784.,  736.,  826.,  772.,  868.,  808.,  910.,
      1024., 1162., 1060., 1204., 1096., 1246., 1132., 1288., 1168., 1330.,
      1384., 1582., 1420., 1624., 1456., 1666., 1492., 1708., 1528., 1750.,
      1744., 2002., 1780., 2044., 1816., 2086., 1852., 2128., 1888., 2170.,
      2104., 2422., 2140., 2464., 2176., 2506., 2212., 2548., 2248., 2590.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24740., 25160., 25580., 26000., 29965., 30490., 31015., 31540., 30700.,
      31240., 31780., 32320., 23624., 24056., 24488., 24920., 24188., 24632.,
      25076., 25520., 31120., 31680., 32240., 32800., 37620., 38320., 39020.,
      39720., 38400., 39120., 39840., 40560., 29472., 30048., 30624., 31200.,
      30064., 30656., 31248., 31840., 37680., 38400., 39120., 39840., 45420.,
      46320., 47220., 48120., 46200., 47120., 48040., 48960., 35392., 36128.,
      36864., 37600., 35984., 36736., 37488., 38240., 20060., 20600., 21140.,
      21680., 23815., 24490., 25165., 25840., 24250., 24940., 25630., 26320.,
      18224., 18776., 19328., 19880., 18548., 19112., 19676., 20240., 23780.,
      24440., 25100., 25760., 28165., 28990., 29815., 30640., 28600., 29440.,
      30280., 31120., 21464., 22136., 22808., 23480., 21788., 22472., 23156.,
      23840.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1250., 1328., 1406., 1484., 1316., 1400., 1484., 1568., 1382., 1472.,
      1562., 1652., 1448., 1544., 1640., 1736., 1514., 1616., 1718., 1820.,
      1910., 2048., 2186., 2324., 1976., 2120., 2264., 2408., 2042., 2192.,
      2342., 2492., 2108., 2264., 2420., 2576., 2174., 2336., 2498., 2660.,
      2570., 2768., 2966., 3164., 2636., 2840., 3044., 3248., 2702., 2912.,
      3122., 3332., 2768., 2984., 3200., 3416., 2834., 3056., 3278., 3500.,
      3230., 3488., 3746., 4004., 3296., 3560., 3824., 4088., 3362., 3632.,
      3902., 4172., 3428., 3704., 3980., 4256., 3494., 3776., 4058., 4340.,
      3890., 4208., 4526., 4844., 3956., 4280., 4604., 4928., 4022., 4352.,
      4682., 5012., 4088., 4424., 4760., 5096., 4154., 4496., 4838., 5180.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12838., 13000., 15575., 15770., 15965., 16160., 12310., 12460., 12610.,
      12760., 16224., 16400., 19650., 19860., 20070., 20280., 15440., 15600.,
      15760., 15920., 19744., 19920., 23850., 24060., 24270., 24480., 18640.,
      18800., 18960., 19120., 10738., 10840., 12800., 12920., 13040., 13160.,
      9850.,  9940.,  10030., 10120., 12778., 12880., 15200., 15320., 15440.,
      15560., 11650., 11740., 11830., 11920.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      721.,  742.,  763.,  784.,  805.,  826.,  847.,  868.,  889.,  910.,
      1141., 1162., 1183., 1204., 1225., 1246., 1267., 1288., 1309., 1330.,
      1561., 1582., 1603., 1624., 1645., 1666., 1687., 1708., 1729., 1750.,
      1981., 2002., 2023., 2044., 2065., 2086., 2107., 2128., 2149., 2170.,
      2401., 2422., 2443., 2464., 2485., 2506., 2527., 2548., 2569., 2590.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24848., 25676., 25160., 26000., 30115., 31150., 30490., 31540., 30865.,
      31930., 31240., 32320., 23768., 24620., 24056., 24920., 24344., 25220.,
      24632., 25520., 31344., 32448., 31680., 32800., 37920., 39300., 38320.,
      39720., 38720., 40140., 39120., 40560., 29744., 30880., 30048., 31200.,
      30352., 31520., 30656., 31840., 38064., 39488., 38400., 39840., 45920.,
      47700., 46320., 48120., 46720., 48540., 47120., 48960., 35824., 37280.,
      36128., 37600., 36432., 37920., 36736., 38240., 20408., 21476., 20600.,
      21680., 24265., 25600., 24490., 25840., 24715., 26080., 24940., 26320.,
      18608., 19700., 18776., 19880., 18944., 20060., 19112., 20240., 24248.,
      25556., 24440., 25760., 28765., 30400., 28990., 30640., 29215., 30880.,
      29440., 31120., 21968., 23300., 22136., 23480., 22304., 23660., 22472.,
      23840.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1292., 1442., 1328., 1484., 1364., 1526., 1400., 1568., 1436., 1610.,
      1472., 1652., 1508., 1694., 1544., 1736., 1580., 1778., 1616., 1820.,
      2012., 2282., 2048., 2324., 2084., 2366., 2120., 2408., 2156., 2450.,
      2192., 2492., 2228., 2534., 2264., 2576., 2300., 2618., 2336., 2660.,
      2732., 3122., 2768., 3164., 2804., 3206., 2840., 3248., 2876., 3290.,
      2912., 3332., 2948., 3374., 2984., 3416., 3020., 3458., 3056., 3500.,
      3452., 3962., 3488., 4004., 3524., 4046., 3560., 4088., 3596., 4130.,
      3632., 4172., 3668., 4214., 3704., 4256., 3740., 4298., 3776., 4340.,
      4172., 4802., 4208., 4844., 4244., 4886., 4280., 4928., 4316., 4970.,
      4352., 5012., 4388., 5054., 4424., 5096., 4460., 5138., 4496., 5180.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48868., 49696., 50524., 51352., 49480., 50320., 51160., 52000., 59195.,
      60230., 61265., 62300., 59930., 60980., 62030., 63080., 60665., 61730.,
      62795., 63860., 61400., 62480., 63560., 64640., 46684., 47536., 48388.,
      49240., 47248., 48112., 48976., 49840., 47812., 48688., 49564., 50440.,
      48376., 49264., 50152., 51040., 61584., 62688., 63792., 64896., 62240.,
      63360., 64480., 65600., 74460., 75840., 77220., 78600., 75240., 76640.,
      78040., 79440., 76020., 77440., 78860., 80280., 76800., 78240., 79680.,
      81120., 58352., 59488., 60624., 61760., 58944., 60096., 61248., 62400.,
      59536., 60704., 61872., 63040., 60128., 61312., 62496., 63680., 74704.,
      76128., 77552., 78976., 75360., 76800., 78240., 79680., 90060., 91840.,
      93620., 95400., 90840., 92640., 94440., 96240., 91620., 93440., 95260.,
      97080., 92400., 94240., 96080., 97920., 70192., 71648., 73104., 74560.,
      70784., 72256., 73728., 75200., 71376., 72864., 74352., 75840., 71968.,
      73472., 74976., 76480., 39748., 40816., 41884., 42952., 40120., 41200.,
      42280., 43360., 47195., 48530., 49865., 51200., 47630., 48980., 50330.,
      51680., 48065., 49430., 50795., 52160., 48500., 49880., 51260., 52640.,
      36124., 37216., 38308., 39400., 36448., 37552., 38656., 39760., 36772.,
      37888., 39004., 40120., 37096., 38224., 39352., 40480., 47188., 48496.,
      49804., 51112., 47560., 48880., 50200., 51520., 55895., 57530., 59165.,
      60800., 56330., 57980., 59630., 61280., 56765., 58430., 60095., 61760.,
      57200., 58880., 60560., 62240., 42604., 43936., 45268., 46600., 42928.,
      44272., 45616., 46960., 43252., 44608., 45964., 47320., 43576., 44944.,
      46312., 47680.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2434., 2584., 2734.,  2884.,  2500., 2656., 2812.,  2968.,  2566.,
      2728., 2890., 3052.,  2632.,  2800., 2968., 3136.,  2698.,  2872.,
      3046., 3220., 2764.,  2944.,  3124., 3304., 2830.,  3016.,  3202.,
      3388., 2896., 3088.,  3280.,  3472., 2962., 3160.,  3358.,  3556.,
      3028., 3232., 3436.,  3640.,  3754., 4024., 4294.,  4564.,  3820.,
      4096., 4372., 4648.,  3886.,  4168., 4450., 4732.,  3952.,  4240.,
      4528., 4816., 4018.,  4312.,  4606., 4900., 4084.,  4384.,  4684.,
      4984., 4150., 4456.,  4762.,  5068., 4216., 4528.,  4840.,  5152.,
      4282., 4600., 4918.,  5236.,  4348., 4672., 4996.,  5320.,  5074.,
      5464., 5854., 6244.,  5140.,  5536., 5932., 6328.,  5206.,  5608.,
      6010., 6412., 5272.,  5680.,  6088., 6496., 5338.,  5752.,  6166.,
      6580., 5404., 5824.,  6244.,  6664., 5470., 5896.,  6322.,  6748.,
      5536., 5968., 6400.,  6832.,  5602., 6040., 6478.,  6916.,  5668.,
      6112., 6556., 7000.,  6394.,  6904., 7414., 7924.,  6460.,  6976.,
      7492., 8008., 6526.,  7048.,  7570., 8092., 6592.,  7120.,  7648.,
      8176., 6658., 7192.,  7726.,  8260., 6724., 7264.,  7804.,  8344.,
      6790., 7336., 7882.,  8428.,  6856., 7408., 7960.,  8512.,  6922.,
      7480., 8038., 8596.,  6988.,  7552., 8116., 8680.,  7714.,  8344.,
      8974., 9604., 7780.,  8416.,  9052., 9688., 7846.,  8488.,  9130.,
      9772., 7912., 8560.,  9208.,  9856., 7978., 8632.,  9286.,  9940.,
      8044., 8704., 9364.,  10024., 8110., 8776., 9442.,  10108., 8176.,
      8848., 9520., 10192., 8242.,  8920., 9598., 10276., 8308.,  8992.,
      9676., 10360.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25514., 25676., 25838., 26000., 30955., 31150., 31345., 31540., 31735.,
      31930., 32125., 32320., 24470., 24620., 24770., 24920., 25070., 25220.,
      25370., 25520., 32272., 32448., 32624., 32800., 39090., 39300., 39510.,
      39720., 39930., 40140., 40350., 40560., 30720., 30880., 31040., 31200.,
      31360., 31520., 31680., 31840., 39312., 39488., 39664., 39840., 47490.,
      47700., 47910., 48120., 48330., 48540., 48750., 48960., 37120., 37280.,
      37440., 37600., 37760., 37920., 38080., 38240., 21374., 21476., 21578.,
      21680., 25480., 25600., 25720., 25840., 25960., 26080., 26200., 26320.,
      19610., 19700., 19790., 19880., 19970., 20060., 20150., 20240., 25454.,
      25556., 25658., 25760., 30280., 30400., 30520., 30640., 30760., 30880.,
      31000., 31120., 23210., 23300., 23390., 23480., 23570., 23660., 23750.,
      23840.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1421., 1442., 1463., 1484., 1505., 1526., 1547., 1568., 1589., 1610.,
      1631., 1652., 1673., 1694., 1715., 1736., 1757., 1778., 1799., 1820.,
      2261., 2282., 2303., 2324., 2345., 2366., 2387., 2408., 2429., 2450.,
      2471., 2492., 2513., 2534., 2555., 2576., 2597., 2618., 2639., 2660.,
      3101., 3122., 3143., 3164., 3185., 3206., 3227., 3248., 3269., 3290.,
      3311., 3332., 3353., 3374., 3395., 3416., 3437., 3458., 3479., 3500.,
      3941., 3962., 3983., 4004., 4025., 4046., 4067., 4088., 4109., 4130.,
      4151., 4172., 4193., 4214., 4235., 4256., 4277., 4298., 4319., 4340.,
      4781., 4802., 4823., 4844., 4865., 4886., 4907., 4928., 4949., 4970.,
      4991., 5012., 5033., 5054., 5075., 5096., 5117., 5138., 5159., 5180.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49384., 51028., 49696., 51352., 50008., 51676., 50320., 52000., 59855.,
      61910., 60230., 62300., 60605., 62690., 60980., 63080., 61355., 63470.,
      61730., 63860., 62105., 64250., 62480., 64640., 47248., 48940., 47536.,
      49240., 47824., 49540., 48112., 49840., 48400., 50140., 48688., 50440.,
      48976., 50740., 49264., 51040., 62352., 64544., 62688., 64896., 63024.,
      65248., 63360., 65600., 75440., 78180., 75840., 78600., 76240., 79020.,
      76640., 79440., 77040., 79860., 77440., 80280., 77840., 80700., 78240.,
      81120., 59184., 61440., 59488., 61760., 59792., 62080., 60096., 62400.,
      60400., 62720., 60704., 63040., 61008., 63360., 61312., 63680., 75792.,
      78624., 76128., 78976., 76464., 79328., 76800., 79680., 91440., 94980.,
      91840., 95400., 92240., 95820., 92640., 96240., 93040., 96660., 93440.,
      97080., 93840., 97500., 94240., 97920., 71344., 74240., 71648., 74560.,
      71952., 74880., 72256., 75200., 72560., 75520., 72864., 75840., 73168.,
      76160., 73472., 76480., 40624., 42748., 40816., 42952., 41008., 43156.,
      41200., 43360., 48305., 50960., 48530., 51200., 48755., 51440., 48980.,
      51680., 49205., 51920., 49430., 52160., 49655., 52400., 49880., 52640.,
      37048., 39220., 37216., 39400., 37384., 39580., 37552., 39760., 37720.,
      39940., 37888., 40120., 38056., 40300., 38224., 40480., 48304., 50908.,
      48496., 51112., 48688., 51316., 48880., 51520., 57305., 60560., 57530.,
      60800., 57755., 61040., 57980., 61280., 58205., 61520., 58430., 61760.,
      58655., 62000., 58880., 62240., 43768., 46420., 43936., 46600., 44104.,
      46780., 44272., 46960., 44440., 47140., 44608., 47320., 44776., 47500.,
      44944., 47680.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2548.,  2842., 2584.,  2884.,  2620.,  2926.,  2656.,  2968.,  2692.,
      3010.,  2728., 3052.,  2764.,  3094.,  2800.,  3136.,  2836.,  3178.,
      2872.,  3220., 2908.,  3262.,  2944.,  3304.,  2980.,  3346.,  3016.,
      3388.,  3052., 3430.,  3088.,  3472.,  3124.,  3514.,  3160.,  3556.,
      3196.,  3598., 3232.,  3640.,  3988.,  4522.,  4024.,  4564.,  4060.,
      4606.,  4096., 4648.,  4132.,  4690.,  4168.,  4732.,  4204.,  4774.,
      4240.,  4816., 4276.,  4858.,  4312.,  4900.,  4348.,  4942.,  4384.,
      4984.,  4420., 5026.,  4456.,  5068.,  4492.,  5110.,  4528.,  5152.,
      4564.,  5194., 4600.,  5236.,  4636.,  5278.,  4672.,  5320.,  5428.,
      6202.,  5464., 6244.,  5500.,  6286.,  5536.,  6328.,  5572.,  6370.,
      5608.,  6412., 5644.,  6454.,  5680.,  6496.,  5716.,  6538.,  5752.,
      6580.,  5788., 6622.,  5824.,  6664.,  5860.,  6706.,  5896.,  6748.,
      5932.,  6790., 5968.,  6832.,  6004.,  6874.,  6040.,  6916.,  6076.,
      6958.,  6112., 7000.,  6868.,  7882.,  6904.,  7924.,  6940.,  7966.,
      6976.,  8008., 7012.,  8050.,  7048.,  8092.,  7084.,  8134.,  7120.,
      8176.,  7156., 8218.,  7192.,  8260.,  7228.,  8302.,  7264.,  8344.,
      7300.,  8386., 7336.,  8428.,  7372.,  8470.,  7408.,  8512.,  7444.,
      8554.,  7480., 8596.,  7516.,  8638.,  7552.,  8680.,  8308.,  9562.,
      8344.,  9604., 8380.,  9646.,  8416.,  9688.,  8452.,  9730.,  8488.,
      9772.,  8524., 9814.,  8560.,  9856.,  8596.,  9898.,  8632.,  9940.,
      8668.,  9982., 8704.,  10024., 8740.,  10066., 8776.,  10108., 8812.,
      10150., 8848., 10192., 8884.,  10234., 8920.,  10276., 8956.,  10318.,
      8992.,  10360.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x8x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97124.,  98768.,  100412., 102056., 97736.,  99392.,  101048., 102704.,
      98348.,  100016., 101684., 103352., 98960.,  100640., 102320., 104000.,
      117655., 119710., 121765., 123820., 118390., 120460., 122530., 124600.,
      119125., 121210., 123295., 125380., 119860., 121960., 124060., 126160.,
      120595., 122710., 124825., 126940., 121330., 123460., 125590., 127720.,
      122065., 124210., 126355., 128500., 122800., 124960., 127120., 129280.,
      92804.,  94496.,  96188.,  97880.,  93368.,  95072.,  96776.,  98480.,
      93932.,  95648.,  97364.,  99080.,  94496.,  96224.,  97952.,  99680.,
      95060.,  96800.,  98540.,  100280., 95624.,  97376.,  99128.,  100880.,
      96188.,  97952.,  99716.,  101480., 96752.,  98528.,  100304., 102080.,
      122512., 124704., 126896., 129088., 123168., 125376., 127584., 129792.,
      123824., 126048., 128272., 130496., 124480., 126720., 128960., 131200.,
      148140., 150880., 153620., 156360., 148920., 151680., 154440., 157200.,
      149700., 152480., 155260., 158040., 150480., 153280., 156080., 158880.,
      151260., 154080., 156900., 159720., 152040., 154880., 157720., 160560.,
      152820., 155680., 158540., 161400., 153600., 156480., 159360., 162240.,
      116112., 118368., 120624., 122880., 116704., 118976., 121248., 123520.,
      117296., 119584., 121872., 124160., 117888., 120192., 122496., 124800.,
      118480., 120800., 123120., 125440., 119072., 121408., 123744., 126080.,
      119664., 122016., 124368., 126720., 120256., 122624., 124992., 127360.,
      148752., 151584., 154416., 157248., 149408., 152256., 155104., 157952.,
      150064., 152928., 155792., 158656., 150720., 153600., 156480., 159360.,
      179340., 182880., 186420., 189960., 180120., 183680., 187240., 190800.,
      180900., 184480., 188060., 191640., 181680., 185280., 188880., 192480.,
      182460., 186080., 189700., 193320., 183240., 186880., 190520., 194160.,
      184020., 187680., 191340., 195000., 184800., 188480., 192160., 195840.,
      139792., 142688., 145584., 148480., 140384., 143296., 146208., 149120.,
      140976., 143904., 146832., 149760., 141568., 144512., 147456., 150400.,
      142160., 145120., 148080., 151040., 142752., 145728., 148704., 151680.,
      143344., 146336., 149328., 152320., 143936., 146944., 149952., 152960.,
      79124.,  81248.,  83372.,  85496.,  79496.,  81632.,  83768.,  85904.,
      79868.,  82016.,  84164.,  86312.,  80240.,  82400.,  84560.,  86720.,
      93955.,  96610.,  99265.,  101920., 94390.,  97060.,  99730.,  102400.,
      94825.,  97510.,  100195., 102880., 95260.,  97960.,  100660., 103360.,
      95695.,  98410.,  101125., 103840., 96130.,  98860.,  101590., 104320.,
      96565.,  99310.,  102055., 104800., 97000.,  99760.,  102520., 105280.,
      71924.,  74096.,  76268.,  78440.,  72248.,  74432.,  76616.,  78800.,
      72572.,  74768.,  76964.,  79160.,  72896.,  75104.,  77312.,  79520.,
      73220.,  75440.,  77660.,  79880.,  73544.,  75776.,  78008.,  80240.,
      73868.,  76112.,  78356.,  80600.,  74192.,  76448.,  78704.,  80960.,
      94004.,  96608.,  99212.,  101816., 94376.,  96992.,  99608.,  102224.,
      94748.,  97376.,  100004., 102632., 95120.,  97760.,  100400., 103040.,
      111355., 114610., 117865., 121120., 111790., 115060., 118330., 121600.,
      112225., 115510., 118795., 122080., 112660., 115960., 119260., 122560.,
      113095., 116410., 119725., 123040., 113530., 116860., 120190., 123520.,
      113965., 117310., 120655., 124000., 114400., 117760., 121120., 124480.,
      84884.,  87536.,  90188.,  92840.,  85208.,  87872.,  90536.,  93200.,
      85532.,  88208.,  90884.,  93560.,  85856.,  88544.,  91232.,  93920.,
      86180.,  88880.,  91580.,  94280.,  86504.,  89216.,  91928.,  94640.,
      86828.,  89552.,  92276.,  95000.,  87152.,  89888.,  92624.,  95360.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x8x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4802.,  5096.,  5390.,  5684.,  4868.,  5168.,  5468.,  5768.,  4934.,
      5240.,  5546.,  5852.,  5000.,  5312.,  5624.,  5936.,  5066.,  5384.,
      5702.,  6020.,  5132.,  5456.,  5780.,  6104.,  5198.,  5528.,  5858.,
      6188.,  5264.,  5600.,  5936.,  6272.,  5330.,  5672.,  6014.,  6356.,
      5396.,  5744.,  6092.,  6440.,  5462.,  5816.,  6170.,  6524.,  5528.,
      5888.,  6248.,  6608.,  5594.,  5960.,  6326.,  6692.,  5660.,  6032.,
      6404.,  6776.,  5726.,  6104.,  6482.,  6860.,  5792.,  6176.,  6560.,
      6944.,  5858.,  6248.,  6638.,  7028.,  5924.,  6320.,  6716.,  7112.,
      5990.,  6392.,  6794.,  7196.,  6056.,  6464.,  6872.,  7280.,  7442.,
      7976.,  8510.,  9044.,  7508.,  8048.,  8588.,  9128.,  7574.,  8120.,
      8666.,  9212.,  7640.,  8192.,  8744.,  9296.,  7706.,  8264.,  8822.,
      9380.,  7772.,  8336.,  8900.,  9464.,  7838.,  8408.,  8978.,  9548.,
      7904.,  8480.,  9056.,  9632.,  7970.,  8552.,  9134.,  9716.,  8036.,
      8624.,  9212.,  9800.,  8102.,  8696.,  9290.,  9884.,  8168.,  8768.,
      9368.,  9968.,  8234.,  8840.,  9446.,  10052., 8300.,  8912.,  9524.,
      10136., 8366.,  8984.,  9602.,  10220., 8432.,  9056.,  9680.,  10304.,
      8498.,  9128.,  9758.,  10388., 8564.,  9200.,  9836.,  10472., 8630.,
      9272.,  9914.,  10556., 8696.,  9344.,  9992.,  10640., 10082., 10856.,
      11630., 12404., 10148., 10928., 11708., 12488., 10214., 11000., 11786.,
      12572., 10280., 11072., 11864., 12656., 10346., 11144., 11942., 12740.,
      10412., 11216., 12020., 12824., 10478., 11288., 12098., 12908., 10544.,
      11360., 12176., 12992., 10610., 11432., 12254., 13076., 10676., 11504.,
      12332., 13160., 10742., 11576., 12410., 13244., 10808., 11648., 12488.,
      13328., 10874., 11720., 12566., 13412., 10940., 11792., 12644., 13496.,
      11006., 11864., 12722., 13580., 11072., 11936., 12800., 13664., 11138.,
      12008., 12878., 13748., 11204., 12080., 12956., 13832., 11270., 12152.,
      13034., 13916., 11336., 12224., 13112., 14000., 12722., 13736., 14750.,
      15764., 12788., 13808., 14828., 15848., 12854., 13880., 14906., 15932.,
      12920., 13952., 14984., 16016., 12986., 14024., 15062., 16100., 13052.,
      14096., 15140., 16184., 13118., 14168., 15218., 16268., 13184., 14240.,
      15296., 16352., 13250., 14312., 15374., 16436., 13316., 14384., 15452.,
      16520., 13382., 14456., 15530., 16604., 13448., 14528., 15608., 16688.,
      13514., 14600., 15686., 16772., 13580., 14672., 15764., 16856., 13646.,
      14744., 15842., 16940., 13712., 14816., 15920., 17024., 13778., 14888.,
      15998., 17108., 13844., 14960., 16076., 17192., 13910., 15032., 16154.,
      17276., 13976., 15104., 16232., 17360., 15362., 16616., 17870., 19124.,
      15428., 16688., 17948., 19208., 15494., 16760., 18026., 19292., 15560.,
      16832., 18104., 19376., 15626., 16904., 18182., 19460., 15692., 16976.,
      18260., 19544., 15758., 17048., 18338., 19628., 15824., 17120., 18416.,
      19712., 15890., 17192., 18494., 19796., 15956., 17264., 18572., 19880.,
      16022., 17336., 18650., 19964., 16088., 17408., 18728., 20048., 16154.,
      17480., 18806., 20132., 16220., 17552., 18884., 20216., 16286., 17624.,
      18962., 20300., 16352., 17696., 19040., 20384., 16418., 17768., 19118.,
      20468., 16484., 17840., 19196., 20552., 16550., 17912., 19274., 20636.,
      16616., 17984., 19352., 20720.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5692., 5848., 7560., 5464.,  5608., 6815., 6980., 9010., 6500.,
      6650., 7970., 8135., 10480., 7550., 7700., 4960., 5068., 6464.,
      4600., 4696., 5716., 5824.,  7416., 5272., 5368.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      451., 472., 493.,  514.,  535.,  598.,  619., 640., 661.,
      682., 745., 766.,  787.,  808.,  829.,  892., 913., 934.,
      955., 976., 1039., 1060., 1081., 1102., 1123.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11012., 11384., 11312., 11696., 14608., 15120., 10544., 10928., 10820.,
      11216., 13165., 13630., 13480., 13960., 17380., 18020., 12520., 13000.,
      12805., 13300., 15370., 15940., 15685., 16270., 20180., 20960., 14515.,
      15100., 14800., 15400., 9464.,  9920.,  9668.,  10136., 12304., 12928.,
      8732.,  9200.,  8912.,  9392.,  10892., 11432., 11096., 11648., 14096.,
      14832., 9992.,  10544., 10172., 10736.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      806.,  902.,  842.,  944.,  878.,  986.,  914.,  1028., 950.,  1070.,
      1058., 1196., 1094., 1238., 1130., 1280., 1166., 1322., 1202., 1364.,
      1310., 1490., 1346., 1532., 1382., 1574., 1418., 1616., 1454., 1658.,
      1562., 1784., 1598., 1826., 1634., 1868., 1670., 1910., 1706., 1952.,
      1814., 2078., 1850., 2120., 1886., 2162., 1922., 2204., 1958., 2246.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21652., 22024., 22396., 22768., 22240., 22624., 23008., 23392., 28704.,
      29216., 29728., 30240., 20704., 21088., 21472., 21856., 21244., 21640.,
      22036., 22432., 25865., 26330., 26795., 27260., 26480., 26960., 27440.,
      27920., 34120., 34760., 35400., 36040., 24560., 25040., 25520., 26000.,
      25115., 25610., 26105., 26600., 30170., 30740., 31310., 31880., 30785.,
      31370., 31955., 32540., 39580., 40360., 41140., 41920., 28445., 29030.,
      29615., 30200., 29000., 29600., 30200., 30800., 18472., 18928., 19384.,
      19840., 18868., 19336., 19804., 20272., 23984., 24608., 25232., 25856.,
      16996., 17464., 17932., 18400., 17344., 17824., 18304., 18784., 21244.,
      21784., 22324., 22864., 21640., 22192., 22744., 23296., 27456., 28192.,
      28928., 29664., 19432., 19984., 20536., 21088., 19780., 20344., 20908.,
      21472.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1516., 1612., 1708., 1804., 1582., 1684., 1786., 1888., 1648., 1756.,
      1864., 1972., 1714., 1828., 1942., 2056., 1780., 1900., 2020., 2140.,
      1978., 2116., 2254., 2392., 2044., 2188., 2332., 2476., 2110., 2260.,
      2410., 2560., 2176., 2332., 2488., 2644., 2242., 2404., 2566., 2728.,
      2440., 2620., 2800., 2980., 2506., 2692., 2878., 3064., 2572., 2764.,
      2956., 3148., 2638., 2836., 3034., 3232., 2704., 2908., 3112., 3316.,
      2902., 3124., 3346., 3568., 2968., 3196., 3424., 3652., 3034., 3268.,
      3502., 3736., 3100., 3340., 3580., 3820., 3166., 3412., 3658., 3904.,
      3364., 3628., 3892., 4156., 3430., 3700., 3970., 4240., 3496., 3772.,
      4048., 4324., 3562., 3844., 4126., 4408., 3628., 3916., 4204., 4492.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11228., 11384., 11540., 11696., 14920., 15120., 10784., 10928., 11072.,
      11216., 13465., 13630., 13795., 13960., 17810., 18020., 12850., 13000.,
      13150., 13300., 15775., 15940., 16105., 16270., 20750., 20960., 14950.,
      15100., 15250., 15400., 9812.,  9920.,  10028., 10136., 12792., 12928.,
      9104.,  9200.,  9296.,  9392.,  11324., 11432., 11540., 11648., 14696.,
      14832., 10448., 10544., 10640., 10736.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      881.,  902.,  923.,  944.,  965.,  986.,  1007., 1028., 1049., 1070.,
      1175., 1196., 1217., 1238., 1259., 1280., 1301., 1322., 1343., 1364.,
      1469., 1490., 1511., 1532., 1553., 1574., 1595., 1616., 1637., 1658.,
      1763., 1784., 1805., 1826., 1847., 1868., 1889., 1910., 1931., 1952.,
      2057., 2078., 2099., 2120., 2141., 2162., 2183., 2204., 2225., 2246.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21724., 22456., 22024., 22768., 22324., 23080., 22624., 23392., 28832.,
      29840., 29216., 30240., 20812., 21568., 21088., 21856., 21364., 22144.,
      21640., 22432., 26015., 26930., 26330., 27260., 26645., 27590., 26960.,
      27920., 34360., 35620., 34760., 36040., 24755., 25700., 25040., 26000.,
      25325., 26300., 25610., 26600., 30425., 31550., 30740., 31880., 31055.,
      32210., 31370., 32540., 39960., 41500., 40360., 41920., 28745., 29900.,
      29030., 30200., 29315., 30500., 29600., 30800., 18724., 19624., 18928.,
      19840., 19132., 20056., 19336., 20272., 24352., 25584., 24608., 25856.,
      17284., 18208., 17464., 18400., 17644., 18592., 17824., 18784., 21580.,
      22648., 21784., 22864., 21988., 23080., 22192., 23296., 27936., 29392.,
      28192., 29664., 19804., 20896., 19984., 21088., 20164., 21280., 20344.,
      21472.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576., 1762., 1612., 1804., 1648., 1846., 1684., 1888., 1720., 1930.,
      1756., 1972., 1792., 2014., 1828., 2056., 1864., 2098., 1900., 2140.,
      2080., 2350., 2116., 2392., 2152., 2434., 2188., 2476., 2224., 2518.,
      2260., 2560., 2296., 2602., 2332., 2644., 2368., 2686., 2404., 2728.,
      2584., 2938., 2620., 2980., 2656., 3022., 2692., 3064., 2728., 3106.,
      2764., 3148., 2800., 3190., 2836., 3232., 2872., 3274., 2908., 3316.,
      3088., 3526., 3124., 3568., 3160., 3610., 3196., 3652., 3232., 3694.,
      3268., 3736., 3304., 3778., 3340., 3820., 3376., 3862., 3412., 3904.,
      3592., 4114., 3628., 4156., 3664., 4198., 3700., 4240., 3736., 4282.,
      3772., 4324., 3808., 4366., 3844., 4408., 3880., 4450., 3916., 4492.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42716., 43448., 44180., 44912., 43304., 44048., 44792., 45536., 43892.,
      44648., 45404., 46160., 44480., 45248., 46016., 46784., 56656., 57664.,
      58672., 59680., 57408., 58432., 59456., 60480., 40868., 41624., 42380.,
      43136., 41408., 42176., 42944., 43712., 41948., 42728., 43508., 44288.,
      42488., 43280., 44072., 44864., 51115., 52030., 52945., 53860., 51730.,
      52660., 53590., 54520., 52345., 53290., 54235., 55180., 52960., 53920.,
      54880., 55840., 67460., 68720., 69980., 71240., 68240., 69520., 70800.,
      72080., 48565., 49510., 50455., 51400., 49120., 50080., 51040., 52000.,
      49675., 50650., 51625., 52600., 50230., 51220., 52210., 53200., 59725.,
      60850., 61975., 63100., 60340., 61480., 62620., 63760., 60955., 62110.,
      63265., 64420., 61570., 62740., 63910., 65080., 78380., 79920., 81460.,
      83000., 79160., 80720., 82280., 83840., 56335., 57490., 58645., 59800.,
      56890., 58060., 59230., 60400., 57445., 58630., 59815., 61000., 58000.,
      59200., 60400., 61600., 36548., 37448., 38348., 39248., 36944., 37856.,
      38768., 39680., 37340., 38264., 39188., 40112., 37736., 38672., 39608.,
      40544., 47472., 48704., 49936., 51168., 47968., 49216., 50464., 51712.,
      33644., 34568., 35492., 36416., 33992., 34928., 35864., 36800., 34340.,
      35288., 36236., 37184., 34688., 35648., 36608., 37568., 42092., 43160.,
      44228., 45296., 42488., 43568., 44648., 45728., 42884., 43976., 45068.,
      46160., 43280., 44384., 45488., 46592., 54416., 55872., 57328., 58784.,
      54912., 56384., 57856., 59328., 38516., 39608., 40700., 41792., 38864.,
      39968., 41072., 42176., 39212., 40328., 41444., 42560., 39560., 40688.,
      41816., 42944.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2966., 3152., 3338., 3524., 3032., 3224., 3416., 3608., 3098., 3296.,
      3494., 3692., 3164., 3368., 3572., 3776., 3230., 3440., 3650., 3860.,
      3296., 3512., 3728., 3944., 3362., 3584., 3806., 4028., 3428., 3656.,
      3884., 4112., 3494., 3728., 3962., 4196., 3560., 3800., 4040., 4280.,
      3890., 4160., 4430., 4700., 3956., 4232., 4508., 4784., 4022., 4304.,
      4586., 4868., 4088., 4376., 4664., 4952., 4154., 4448., 4742., 5036.,
      4220., 4520., 4820., 5120., 4286., 4592., 4898., 5204., 4352., 4664.,
      4976., 5288., 4418., 4736., 5054., 5372., 4484., 4808., 5132., 5456.,
      4814., 5168., 5522., 5876., 4880., 5240., 5600., 5960., 4946., 5312.,
      5678., 6044., 5012., 5384., 5756., 6128., 5078., 5456., 5834., 6212.,
      5144., 5528., 5912., 6296., 5210., 5600., 5990., 6380., 5276., 5672.,
      6068., 6464., 5342., 5744., 6146., 6548., 5408., 5816., 6224., 6632.,
      5738., 6176., 6614., 7052., 5804., 6248., 6692., 7136., 5870., 6320.,
      6770., 7220., 5936., 6392., 6848., 7304., 6002., 6464., 6926., 7388.,
      6068., 6536., 7004., 7472., 6134., 6608., 7082., 7556., 6200., 6680.,
      7160., 7640., 6266., 6752., 7238., 7724., 6332., 6824., 7316., 7808.,
      6662., 7184., 7706., 8228., 6728., 7256., 7784., 8312., 6794., 7328.,
      7862., 8396., 6860., 7400., 7940., 8480., 6926., 7472., 8018., 8564.,
      6992., 7544., 8096., 8648., 7058., 7616., 8174., 8732., 7124., 7688.,
      8252., 8816., 7190., 7760., 8330., 8900., 7256., 7832., 8408., 8984.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22300., 22456., 22612., 22768., 22924., 23080., 23236., 23392., 29640.,
      29840., 30040., 30240., 21424., 21568., 21712., 21856., 22000., 22144.,
      22288., 22432., 26765., 26930., 27095., 27260., 27425., 27590., 27755.,
      27920., 35410., 35620., 35830., 36040., 25550., 25700., 25850., 26000.,
      26150., 26300., 26450., 26600., 31385., 31550., 31715., 31880., 32045.,
      32210., 32375., 32540., 41290., 41500., 41710., 41920., 29750., 29900.,
      30050., 30200., 30350., 30500., 30650., 30800., 19516., 19624., 19732.,
      19840., 19948., 20056., 20164., 20272., 25448., 25584., 25720., 25856.,
      18112., 18208., 18304., 18400., 18496., 18592., 18688., 18784., 22540.,
      22648., 22756., 22864., 22972., 23080., 23188., 23296., 29256., 29392.,
      29528., 29664., 20800., 20896., 20992., 21088., 21184., 21280., 21376.,
      21472.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1741., 1762., 1783., 1804., 1825., 1846., 1867., 1888., 1909., 1930.,
      1951., 1972., 1993., 2014., 2035., 2056., 2077., 2098., 2119., 2140.,
      2329., 2350., 2371., 2392., 2413., 2434., 2455., 2476., 2497., 2518.,
      2539., 2560., 2581., 2602., 2623., 2644., 2665., 2686., 2707., 2728.,
      2917., 2938., 2959., 2980., 3001., 3022., 3043., 3064., 3085., 3106.,
      3127., 3148., 3169., 3190., 3211., 3232., 3253., 3274., 3295., 3316.,
      3505., 3526., 3547., 3568., 3589., 3610., 3631., 3652., 3673., 3694.,
      3715., 3736., 3757., 3778., 3799., 3820., 3841., 3862., 3883., 3904.,
      4093., 4114., 4135., 4156., 4177., 4198., 4219., 4240., 4261., 4282.,
      4303., 4324., 4345., 4366., 4387., 4408., 4429., 4450., 4471., 4492.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      43148., 44600., 43448., 44912., 43748., 45224., 44048., 45536., 44348.,
      45848., 44648., 46160., 44948., 46472., 45248., 46784., 57280., 59280.,
      57664., 59680., 58048., 60080., 58432., 60480., 41348., 42848., 41624.,
      43136., 41900., 43424., 42176., 43712., 42452., 44000., 42728., 44288.,
      43004., 44576., 43280., 44864., 51715., 53530., 52030., 53860., 52345.,
      54190., 52660., 54520., 52975., 54850., 53290., 55180., 53605., 55510.,
      53920., 55840., 68320., 70820., 68720., 71240., 69120., 71660., 69520.,
      72080., 49225., 51100., 49510., 51400., 49795., 51700., 50080., 52000.,
      50365., 52300., 50650., 52600., 50935., 52900., 51220., 53200., 60535.,
      62770., 60850., 63100., 61165., 63430., 61480., 63760., 61795., 64090.,
      62110., 64420., 62425., 64750., 62740., 65080., 79520., 82580., 79920.,
      83000., 80320., 83420., 80720., 83840., 57205., 59500., 57490., 59800.,
      57775., 60100., 58060., 60400., 58345., 60700., 58630., 61000., 58915.,
      61300., 59200., 61600., 37244., 39032., 37448., 39248., 37652., 39464.,
      37856., 39680., 38060., 39896., 38264., 40112., 38468., 40328., 38672.,
      40544., 48448., 50896., 48704., 51168., 48960., 51440., 49216., 51712.,
      34388., 36224., 34568., 36416., 34748., 36608., 34928., 36800., 35108.,
      36992., 35288., 37184., 35468., 37376., 35648., 37568., 42956., 45080.,
      43160., 45296., 43364., 45512., 43568., 45728., 43772., 45944., 43976.,
      46160., 44180., 46376., 44384., 46592., 55616., 58512., 55872., 58784.,
      56128., 59056., 56384., 59328., 39428., 41600., 39608., 41792., 39788.,
      41984., 39968., 42176., 40148., 42368., 40328., 42560., 40508., 42752.,
      40688., 42944.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3116., 3482., 3152., 3524., 3188., 3566., 3224., 3608., 3260., 3650.,
      3296., 3692., 3332., 3734., 3368., 3776., 3404., 3818., 3440., 3860.,
      3476., 3902., 3512., 3944., 3548., 3986., 3584., 4028., 3620., 4070.,
      3656., 4112., 3692., 4154., 3728., 4196., 3764., 4238., 3800., 4280.,
      4124., 4658., 4160., 4700., 4196., 4742., 4232., 4784., 4268., 4826.,
      4304., 4868., 4340., 4910., 4376., 4952., 4412., 4994., 4448., 5036.,
      4484., 5078., 4520., 5120., 4556., 5162., 4592., 5204., 4628., 5246.,
      4664., 5288., 4700., 5330., 4736., 5372., 4772., 5414., 4808., 5456.,
      5132., 5834., 5168., 5876., 5204., 5918., 5240., 5960., 5276., 6002.,
      5312., 6044., 5348., 6086., 5384., 6128., 5420., 6170., 5456., 6212.,
      5492., 6254., 5528., 6296., 5564., 6338., 5600., 6380., 5636., 6422.,
      5672., 6464., 5708., 6506., 5744., 6548., 5780., 6590., 5816., 6632.,
      6140., 7010., 6176., 7052., 6212., 7094., 6248., 7136., 6284., 7178.,
      6320., 7220., 6356., 7262., 6392., 7304., 6428., 7346., 6464., 7388.,
      6500., 7430., 6536., 7472., 6572., 7514., 6608., 7556., 6644., 7598.,
      6680., 7640., 6716., 7682., 6752., 7724., 6788., 7766., 6824., 7808.,
      7148., 8186., 7184., 8228., 7220., 8270., 7256., 8312., 7292., 8354.,
      7328., 8396., 7364., 8438., 7400., 8480., 7436., 8522., 7472., 8564.,
      7508., 8606., 7544., 8648., 7580., 8690., 7616., 8732., 7652., 8774.,
      7688., 8816., 7724., 8858., 7760., 8900., 7796., 8942., 7832., 8984.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84844.,  86296.,  87748.,  89200.,  85432.,  86896.,  88360.,  89824.,
      86020.,  87496.,  88972.,  90448.,  86608.,  88096.,  89584.,  91072.,
      87196.,  88696.,  90196.,  91696.,  87784.,  89296.,  90808.,  92320.,
      88372.,  89896.,  91420.,  92944.,  88960.,  90496.,  92032.,  93568.,
      112560., 114560., 116560., 118560., 113312., 115328., 117344., 119360.,
      114064., 116096., 118128., 120160., 114816., 116864., 118912., 120960.,
      81196.,  82696.,  84196.,  85696.,  81736.,  83248.,  84760.,  86272.,
      82276.,  83800.,  85324.,  86848.,  82816.,  84352.,  85888.,  87424.,
      83356.,  84904.,  86452.,  88000.,  83896.,  85456.,  87016.,  88576.,
      84436.,  86008.,  87580.,  89152.,  84976.,  86560.,  88144.,  89728.,
      101615., 103430., 105245., 107060., 102230., 104060., 105890., 107720.,
      102845., 104690., 106535., 108380., 103460., 105320., 107180., 109040.,
      104075., 105950., 107825., 109700., 104690., 106580., 108470., 110360.,
      105305., 107210., 109115., 111020., 105920., 107840., 109760., 111680.,
      134140., 136640., 139140., 141640., 134920., 137440., 139960., 142480.,
      135700., 138240., 140780., 143320., 136480., 139040., 141600., 144160.,
      96575.,  98450.,  100325., 102200., 97130.,  99020.,  100910., 102800.,
      97685.,  99590.,  101495., 103400., 98240.,  100160., 102080., 104000.,
      98795.,  100730., 102665., 104600., 99350.,  101300., 103250., 105200.,
      99905.,  101870., 103835., 105800., 100460., 102440., 104420., 106400.,
      118835., 121070., 123305., 125540., 119450., 121700., 123950., 126200.,
      120065., 122330., 124595., 126860., 120680., 122960., 125240., 127520.,
      121295., 123590., 125885., 128180., 121910., 124220., 126530., 128840.,
      122525., 124850., 127175., 129500., 123140., 125480., 127820., 130160.,
      155980., 159040., 162100., 165160., 156760., 159840., 162920., 166000.,
      157540., 160640., 163740., 166840., 158320., 161440., 164560., 167680.,
      112115., 114410., 116705., 119000., 112670., 114980., 117290., 119600.,
      113225., 115550., 117875., 120200., 113780., 116120., 118460., 120800.,
      114335., 116690., 119045., 121400., 114890., 117260., 119630., 122000.,
      115445., 117830., 120215., 122600., 116000., 118400., 120800., 123200.,
      72700.,  74488.,  76276.,  78064.,  73096.,  74896.,  76696.,  78496.,
      73492.,  75304.,  77116.,  78928.,  73888.,  75712.,  77536.,  79360.,
      74284.,  76120.,  77956.,  79792.,  74680.,  76528.,  78376.,  80224.,
      75076.,  76936.,  78796.,  80656.,  75472.,  77344.,  79216.,  81088.,
      94448.,  96896.,  99344.,  101792., 94944.,  97408.,  99872.,  102336.,
      95440.,  97920.,  100400., 102880., 95936.,  98432.,  100928., 103424.,
      66940.,  68776.,  70612.,  72448.,  67288.,  69136.,  70984.,  72832.,
      67636.,  69496.,  71356.,  73216.,  67984.,  69856.,  71728.,  73600.,
      68332.,  70216.,  72100.,  73984.,  68680.,  70576.,  72472.,  74368.,
      69028.,  70936.,  72844.,  74752.,  69376.,  71296.,  73216.,  75136.,
      83788.,  85912.,  88036.,  90160.,  84184.,  86320.,  88456.,  90592.,
      84580.,  86728.,  88876.,  91024.,  84976.,  87136.,  89296.,  91456.,
      85372.,  87544.,  89716.,  91888.,  85768.,  87952.,  90136.,  92320.,
      86164.,  88360.,  90556.,  92752.,  86560.,  88768.,  90976.,  93184.,
      108336., 111232., 114128., 117024., 108832., 111744., 114656., 117568.,
      109328., 112256., 115184., 118112., 109824., 112768., 115712., 118656.,
      76684.,  78856.,  81028.,  83200.,  77032.,  79216.,  81400.,  83584.,
      77380.,  79576.,  81772.,  83968.,  77728.,  79936.,  82144.,  84352.,
      78076.,  80296.,  82516.,  84736.,  78424.,  80656.,  82888.,  85120.,
      78772.,  81016.,  83260.,  85504.,  79120.,  81376.,  83632.,  85888.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5866.,  6232.,  6598.,  6964.,  5932.,  6304.,  6676.,  7048.,  5998.,
      6376.,  6754.,  7132.,  6064.,  6448.,  6832.,  7216.,  6130.,  6520.,
      6910.,  7300.,  6196.,  6592.,  6988.,  7384.,  6262.,  6664.,  7066.,
      7468.,  6328.,  6736.,  7144.,  7552.,  6394.,  6808.,  7222.,  7636.,
      6460.,  6880.,  7300.,  7720.,  6526.,  6952.,  7378.,  7804.,  6592.,
      7024.,  7456.,  7888.,  6658.,  7096.,  7534.,  7972.,  6724.,  7168.,
      7612.,  8056.,  6790.,  7240.,  7690.,  8140.,  6856.,  7312.,  7768.,
      8224.,  6922.,  7384.,  7846.,  8308.,  6988.,  7456.,  7924.,  8392.,
      7054.,  7528.,  8002.,  8476.,  7120.,  7600.,  8080.,  8560.,  7714.,
      8248.,  8782.,  9316.,  7780.,  8320.,  8860.,  9400.,  7846.,  8392.,
      8938.,  9484.,  7912.,  8464.,  9016.,  9568.,  7978.,  8536.,  9094.,
      9652.,  8044.,  8608.,  9172.,  9736.,  8110.,  8680.,  9250.,  9820.,
      8176.,  8752.,  9328.,  9904.,  8242.,  8824.,  9406.,  9988.,  8308.,
      8896.,  9484.,  10072., 8374.,  8968.,  9562.,  10156., 8440.,  9040.,
      9640.,  10240., 8506.,  9112.,  9718.,  10324., 8572.,  9184.,  9796.,
      10408., 8638.,  9256.,  9874.,  10492., 8704.,  9328.,  9952.,  10576.,
      8770.,  9400.,  10030., 10660., 8836.,  9472.,  10108., 10744., 8902.,
      9544.,  10186., 10828., 8968.,  9616.,  10264., 10912., 9562.,  10264.,
      10966., 11668., 9628.,  10336., 11044., 11752., 9694.,  10408., 11122.,
      11836., 9760.,  10480., 11200., 11920., 9826.,  10552., 11278., 12004.,
      9892.,  10624., 11356., 12088., 9958.,  10696., 11434., 12172., 10024.,
      10768., 11512., 12256., 10090., 10840., 11590., 12340., 10156., 10912.,
      11668., 12424., 10222., 10984., 11746., 12508., 10288., 11056., 11824.,
      12592., 10354., 11128., 11902., 12676., 10420., 11200., 11980., 12760.,
      10486., 11272., 12058., 12844., 10552., 11344., 12136., 12928., 10618.,
      11416., 12214., 13012., 10684., 11488., 12292., 13096., 10750., 11560.,
      12370., 13180., 10816., 11632., 12448., 13264., 11410., 12280., 13150.,
      14020., 11476., 12352., 13228., 14104., 11542., 12424., 13306., 14188.,
      11608., 12496., 13384., 14272., 11674., 12568., 13462., 14356., 11740.,
      12640., 13540., 14440., 11806., 12712., 13618., 14524., 11872., 12784.,
      13696., 14608., 11938., 12856., 13774., 14692., 12004., 12928., 13852.,
      14776., 12070., 13000., 13930., 14860., 12136., 13072., 14008., 14944.,
      12202., 13144., 14086., 15028., 12268., 13216., 14164., 15112., 12334.,
      13288., 14242., 15196., 12400., 13360., 14320., 15280., 12466., 13432.,
      14398., 15364., 12532., 13504., 14476., 15448., 12598., 13576., 14554.,
      15532., 12664., 13648., 14632., 15616., 13258., 14296., 15334., 16372.,
      13324., 14368., 15412., 16456., 13390., 14440., 15490., 16540., 13456.,
      14512., 15568., 16624., 13522., 14584., 15646., 16708., 13588., 14656.,
      15724., 16792., 13654., 14728., 15802., 16876., 13720., 14800., 15880.,
      16960., 13786., 14872., 15958., 17044., 13852., 14944., 16036., 17128.,
      13918., 15016., 16114., 17212., 13984., 15088., 16192., 17296., 14050.,
      15160., 16270., 17380., 14116., 15232., 16348., 17464., 14182., 15304.,
      16426., 17548., 14248., 15376., 16504., 17632., 14314., 15448., 16582.,
      17716., 14380., 15520., 16660., 17800., 14446., 15592., 16738., 17884.,
      14512., 15664., 16816., 17968.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6592., 8520., 8720.,  6304.,  6448., 7880., 10170., 10380., 7490.,
      7640., 9200., 11850., 12060., 8690., 8840., 5728.,  7304.,  7440.,
      5296., 5392., 6592.,  8392.,  8528., 6064., 6160.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      509.,  530.,  551.,  572.,  593.,  677.,  698.,  719.,  740.,
      761.,  845.,  866.,  887.,  908.,  929.,  1013., 1034., 1055.,
      1076., 1097., 1181., 1202., 1223., 1244., 1265.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12752., 13184., 16464., 17040., 16848., 17440., 12164., 12608., 12440.,
      12896., 15220., 15760., 19620., 20340., 20020., 20760., 14425., 14980.,
      14710., 15280., 17740., 18400., 22820., 23700., 23220., 24120., 16705.,
      17380., 16990., 17680., 10928., 11456., 13904., 14608., 14160., 14880.,
      10052., 10592., 10232., 10784., 12560., 13184., 15952., 16784., 16208.,
      17056., 11492., 12128., 11672., 12320.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      910.,  1018., 946.,  1060., 982.,  1102., 1018., 1144., 1054., 1186.,
      1198., 1354., 1234., 1396., 1270., 1438., 1306., 1480., 1342., 1522.,
      1486., 1690., 1522., 1732., 1558., 1774., 1594., 1816., 1630., 1858.,
      1774., 2026., 1810., 2068., 1846., 2110., 1882., 2152., 1918., 2194.,
      2062., 2362., 2098., 2404., 2134., 2446., 2170., 2488., 2206., 2530.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25072., 25504., 25936., 26368., 32352., 32928., 33504., 34080., 33104.,
      33696., 34288., 34880., 23884., 24328., 24772., 25216., 24424., 24880.,
      25336., 25792., 29900., 30440., 30980., 31520., 38520., 39240., 39960.,
      40680., 39300., 40040., 40780., 41520., 28295., 28850., 29405., 29960.,
      28850., 29420., 29990., 30560., 34820., 35480., 36140., 36800., 44760.,
      45640., 46520., 47400., 45540., 46440., 47340., 48240., 32735., 33410.,
      34085., 34760., 33290., 33980., 34670., 35360., 21328., 21856., 22384.,
      22912., 27104., 27808., 28512., 29216., 27600., 28320., 29040., 29760.,
      19564., 20104., 20644., 21184., 19912., 20464., 21016., 21568., 24496.,
      25120., 25744., 26368., 31072., 31904., 32736., 33568., 31568., 32416.,
      33264., 34112., 22348., 22984., 23620., 24256., 22696., 23344., 23992.,
      24640.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1712., 1820., 1928., 2036., 1778., 1892., 2006., 2120., 1844., 1964.,
      2084., 2204., 1910., 2036., 2162., 2288., 1976., 2108., 2240., 2372.,
      2240., 2396., 2552., 2708., 2306., 2468., 2630., 2792., 2372., 2540.,
      2708., 2876., 2438., 2612., 2786., 2960., 2504., 2684., 2864., 3044.,
      2768., 2972., 3176., 3380., 2834., 3044., 3254., 3464., 2900., 3116.,
      3332., 3548., 2966., 3188., 3410., 3632., 3032., 3260., 3488., 3716.,
      3296., 3548., 3800., 4052., 3362., 3620., 3878., 4136., 3428., 3692.,
      3956., 4220., 3494., 3764., 4034., 4304., 3560., 3836., 4112., 4388.,
      3824., 4124., 4424., 4724., 3890., 4196., 4502., 4808., 3956., 4268.,
      4580., 4892., 4022., 4340., 4658., 4976., 4088., 4412., 4736., 5060.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13028., 13184., 16840., 17040., 17240., 17440., 12464., 12608., 12752.,
      12896., 15595., 15760., 20130., 20340., 20550., 20760., 14830., 14980.,
      15130., 15280., 18235., 18400., 23490., 23700., 23910., 24120., 17230.,
      17380., 17530., 17680., 11348., 11456., 14472., 14608., 14744., 14880.,
      10496., 10592., 10688., 10784., 13076., 13184., 16648., 16784., 16920.,
      17056., 12032., 12128., 12224., 12320.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      997.,  1018., 1039., 1060., 1081., 1102., 1123., 1144., 1165., 1186.,
      1333., 1354., 1375., 1396., 1417., 1438., 1459., 1480., 1501., 1522.,
      1669., 1690., 1711., 1732., 1753., 1774., 1795., 1816., 1837., 1858.,
      2005., 2026., 2047., 2068., 2089., 2110., 2131., 2152., 2173., 2194.,
      2341., 2362., 2383., 2404., 2425., 2446., 2467., 2488., 2509., 2530.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25204., 26056., 25504., 26368., 32544., 33680., 32928., 34080., 33312.,
      34480., 33696., 34880., 24052., 24928., 24328., 25216., 24604., 25504.,
      24880., 25792., 30125., 31190., 30440., 31520., 38840., 40260., 39240.,
      40680., 39640., 41100., 40040., 41520., 28565., 29660., 28850., 29960.,
      29135., 30260., 29420., 30560., 35165., 36470., 35480., 36800., 45240.,
      46980., 45640., 47400., 46040., 47820., 46440., 48240., 33125., 34460.,
      33410., 34760., 33695., 35060., 33980., 35360., 21652., 22696., 21856.,
      22912., 27552., 28944., 27808., 29216., 28064., 29488., 28320., 29760.,
      19924., 20992., 20104., 21184., 20284., 21376., 20464., 21568., 24916.,
      26152., 25120., 26368., 31648., 33296., 31904., 33568., 32160., 33840.,
      32416., 34112., 22804., 24064., 22984., 24256., 23164., 24448., 23344.,
      24640.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1784., 1994., 1820., 2036., 1856., 2078., 1892., 2120., 1928., 2162.,
      1964., 2204., 2000., 2246., 2036., 2288., 2072., 2330., 2108., 2372.,
      2360., 2666., 2396., 2708., 2432., 2750., 2468., 2792., 2504., 2834.,
      2540., 2876., 2576., 2918., 2612., 2960., 2648., 3002., 2684., 3044.,
      2936., 3338., 2972., 3380., 3008., 3422., 3044., 3464., 3080., 3506.,
      3116., 3548., 3152., 3590., 3188., 3632., 3224., 3674., 3260., 3716.,
      3512., 4010., 3548., 4052., 3584., 4094., 3620., 4136., 3656., 4178.,
      3692., 4220., 3728., 4262., 3764., 4304., 3800., 4346., 3836., 4388.,
      4088., 4682., 4124., 4724., 4160., 4766., 4196., 4808., 4232., 4850.,
      4268., 4892., 4304., 4934., 4340., 4976., 4376., 5018., 4412., 5060.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49556., 50408., 51260., 52112., 50144., 51008., 51872., 52736., 63952.,
      65088., 66224., 67360., 64704., 65856., 67008., 68160., 65456., 66624.,
      67792., 68960., 66208., 67392., 68576., 69760., 47228., 48104., 48980.,
      49856., 47768., 48656., 49544., 50432., 48308., 49208., 50108., 51008.,
      48848., 49760., 50672., 51584., 59185., 60250., 61315., 62380., 59800.,
      60880., 61960., 63040., 76260., 77680., 79100., 80520., 77040., 78480.,
      79920., 81360., 77820., 79280., 80740., 82200., 78600., 80080., 81560.,
      83040., 56035., 57130., 58225., 59320., 56590., 57700., 58810., 59920.,
      57145., 58270., 59395., 60520., 57700., 58840., 59980., 61120., 69025.,
      70330., 71635., 72940., 69640., 70960., 72280., 73600., 88740., 90480.,
      92220., 93960., 89520., 91280., 93040., 94800., 90300., 92080., 93860.,
      95640., 91080., 92880., 94680., 96480., 64915., 66250., 67585., 68920.,
      65470., 66820., 68170., 69520., 66025., 67390., 68755., 70120., 66580.,
      67960., 69340., 70720., 42260., 43304., 44348., 45392., 42656., 43712.,
      44768., 45824., 53712., 55104., 56496., 57888., 54208., 55616., 57024.,
      58432., 54704., 56128., 57552., 58976., 55200., 56640., 58080., 59520.,
      38780., 39848., 40916., 41984., 39128., 40208., 41288., 42368., 39476.,
      40568., 41660., 42752., 39824., 40928., 42032., 43136., 48596., 49832.,
      51068., 52304., 48992., 50240., 51488., 52736., 61648., 63296., 64944.,
      66592., 62144., 63808., 65472., 67136., 62640., 64320., 66000., 67680.,
      63136., 64832., 66528., 68224., 44348., 45608., 46868., 48128., 44696.,
      45968., 47240., 48512., 45044., 46328., 47612., 48896., 45392., 46688.,
      47984., 49280.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3358., 3568., 3778., 3988., 3424., 3640.,  3856., 4072., 3490., 3712.,
      3934., 4156., 3556., 3784., 4012., 4240.,  3622., 3856., 4090., 4324.,
      3688., 3928., 4168., 4408., 3754., 4000.,  4246., 4492., 3820., 4072.,
      4324., 4576., 3886., 4144., 4402., 4660.,  3952., 4216., 4480., 4744.,
      4414., 4720., 5026., 5332., 4480., 4792.,  5104., 5416., 4546., 4864.,
      5182., 5500., 4612., 4936., 5260., 5584.,  4678., 5008., 5338., 5668.,
      4744., 5080., 5416., 5752., 4810., 5152.,  5494., 5836., 4876., 5224.,
      5572., 5920., 4942., 5296., 5650., 6004.,  5008., 5368., 5728., 6088.,
      5470., 5872., 6274., 6676., 5536., 5944.,  6352., 6760., 5602., 6016.,
      6430., 6844., 5668., 6088., 6508., 6928.,  5734., 6160., 6586., 7012.,
      5800., 6232., 6664., 7096., 5866., 6304.,  6742., 7180., 5932., 6376.,
      6820., 7264., 5998., 6448., 6898., 7348.,  6064., 6520., 6976., 7432.,
      6526., 7024., 7522., 8020., 6592., 7096.,  7600., 8104., 6658., 7168.,
      7678., 8188., 6724., 7240., 7756., 8272.,  6790., 7312., 7834., 8356.,
      6856., 7384., 7912., 8440., 6922., 7456.,  7990., 8524., 6988., 7528.,
      8068., 8608., 7054., 7600., 8146., 8692.,  7120., 7672., 8224., 8776.,
      7582., 8176., 8770., 9364., 7648., 8248.,  8848., 9448., 7714., 8320.,
      8926., 9532., 7780., 8392., 9004., 9616.,  7846., 8464., 9082., 9700.,
      7912., 8536., 9160., 9784., 7978., 8608.,  9238., 9868., 8044., 8680.,
      9316., 9952., 8110., 8752., 9394., 10036., 8176., 8824., 9472., 10120.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25900., 26056., 26212., 26368., 33480., 33680., 33880., 34080., 34280.,
      34480., 34680., 34880., 24784., 24928., 25072., 25216., 25360., 25504.,
      25648., 25792., 31025., 31190., 31355., 31520., 40050., 40260., 40470.,
      40680., 40890., 41100., 41310., 41520., 29510., 29660., 29810., 29960.,
      30110., 30260., 30410., 30560., 36305., 36470., 36635., 36800., 46770.,
      46980., 47190., 47400., 47610., 47820., 48030., 48240., 34310., 34460.,
      34610., 34760., 34910., 35060., 35210., 35360., 22588., 22696., 22804.,
      22912., 28808., 28944., 29080., 29216., 29352., 29488., 29624., 29760.,
      20896., 20992., 21088., 21184., 21280., 21376., 21472., 21568., 26044.,
      26152., 26260., 26368., 33160., 33296., 33432., 33568., 33704., 33840.,
      33976., 34112., 23968., 24064., 24160., 24256., 24352., 24448., 24544.,
      24640.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1973., 1994., 2015., 2036., 2057., 2078., 2099., 2120., 2141., 2162.,
      2183., 2204., 2225., 2246., 2267., 2288., 2309., 2330., 2351., 2372.,
      2645., 2666., 2687., 2708., 2729., 2750., 2771., 2792., 2813., 2834.,
      2855., 2876., 2897., 2918., 2939., 2960., 2981., 3002., 3023., 3044.,
      3317., 3338., 3359., 3380., 3401., 3422., 3443., 3464., 3485., 3506.,
      3527., 3548., 3569., 3590., 3611., 3632., 3653., 3674., 3695., 3716.,
      3989., 4010., 4031., 4052., 4073., 4094., 4115., 4136., 4157., 4178.,
      4199., 4220., 4241., 4262., 4283., 4304., 4325., 4346., 4367., 4388.,
      4661., 4682., 4703., 4724., 4745., 4766., 4787., 4808., 4829., 4850.,
      4871., 4892., 4913., 4934., 4955., 4976., 4997., 5018., 5039., 5060.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50108., 51800., 50408., 52112., 50708., 52424., 51008., 52736., 64704.,
      66960., 65088., 67360., 65472., 67760., 65856., 68160., 66240., 68560.,
      66624., 68960., 67008., 69360., 67392., 69760., 47828., 49568., 48104.,
      49856., 48380., 50144., 48656., 50432., 48932., 50720., 49208., 51008.,
      49484., 51296., 49760., 51584., 59935., 62050., 60250., 62380., 60565.,
      62710., 60880., 63040., 77280., 80100., 77680., 80520., 78080., 80940.,
      78480., 81360., 78880., 81780., 79280., 82200., 79680., 82620., 80080.,
      83040., 56845., 59020., 57130., 59320., 57415., 59620., 57700., 59920.,
      57985., 60220., 58270., 60520., 58555., 60820., 58840., 61120., 70015.,
      72610., 70330., 72940., 70645., 73270., 70960., 73600., 90080., 93540.,
      90480., 93960., 90880., 94380., 91280., 94800., 91680., 95220., 92080.,
      95640., 92480., 96060., 92880., 96480., 65965., 68620., 66250., 68920.,
      66535., 69220., 66820., 69520., 67105., 69820., 67390., 70120., 67675.,
      70420., 67960., 70720., 43100., 45176., 43304., 45392., 43508., 45608.,
      43712., 45824., 54848., 57616., 55104., 57888., 55360., 58160., 55616.,
      58432., 55872., 58704., 56128., 58976., 56384., 59248., 56640., 59520.,
      39668., 41792., 39848., 41984., 40028., 42176., 40208., 42368., 40388.,
      42560., 40568., 42752., 40748., 42944., 40928., 43136., 49628., 52088.,
      49832., 52304., 50036., 52520., 50240., 52736., 63040., 66320., 63296.,
      66592., 63552., 66864., 63808., 67136., 64064., 67408., 64320., 67680.,
      64576., 67952., 64832., 68224., 45428., 47936., 45608., 48128., 45788.,
      48320., 45968., 48512., 46148., 48704., 46328., 48896., 46508., 49088.,
      46688., 49280.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3532., 3946., 3568., 3988., 3604., 4030.,  3640., 4072.,  3676., 4114.,
      3712., 4156., 3748., 4198., 3784., 4240.,  3820., 4282.,  3856., 4324.,
      3892., 4366., 3928., 4408., 3964., 4450.,  4000., 4492.,  4036., 4534.,
      4072., 4576., 4108., 4618., 4144., 4660.,  4180., 4702.,  4216., 4744.,
      4684., 5290., 4720., 5332., 4756., 5374.,  4792., 5416.,  4828., 5458.,
      4864., 5500., 4900., 5542., 4936., 5584.,  4972., 5626.,  5008., 5668.,
      5044., 5710., 5080., 5752., 5116., 5794.,  5152., 5836.,  5188., 5878.,
      5224., 5920., 5260., 5962., 5296., 6004.,  5332., 6046.,  5368., 6088.,
      5836., 6634., 5872., 6676., 5908., 6718.,  5944., 6760.,  5980., 6802.,
      6016., 6844., 6052., 6886., 6088., 6928.,  6124., 6970.,  6160., 7012.,
      6196., 7054., 6232., 7096., 6268., 7138.,  6304., 7180.,  6340., 7222.,
      6376., 7264., 6412., 7306., 6448., 7348.,  6484., 7390.,  6520., 7432.,
      6988., 7978., 7024., 8020., 7060., 8062.,  7096., 8104.,  7132., 8146.,
      7168., 8188., 7204., 8230., 7240., 8272.,  7276., 8314.,  7312., 8356.,
      7348., 8398., 7384., 8440., 7420., 8482.,  7456., 8524.,  7492., 8566.,
      7528., 8608., 7564., 8650., 7600., 8692.,  7636., 8734.,  7672., 8776.,
      8140., 9322., 8176., 9364., 8212., 9406.,  8248., 9448.,  8284., 9490.,
      8320., 9532., 8356., 9574., 8392., 9616.,  8428., 9658.,  8464., 9700.,
      8500., 9742., 8536., 9784., 8572., 9826.,  8608., 9868.,  8644., 9910.,
      8680., 9952., 8716., 9994., 8752., 10036., 8788., 10078., 8824., 10120.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      98524.,  100216., 101908., 103600., 99112.,  100816., 102520., 104224.,
      99700.,  101416., 103132., 104848., 100288., 102016., 103744., 105472.,
      127152., 129408., 131664., 133920., 127904., 130176., 132448., 134720.,
      128656., 130944., 133232., 135520., 129408., 131712., 134016., 136320.,
      130160., 132480., 134800., 137120., 130912., 133248., 135584., 137920.,
      131664., 134016., 136368., 138720., 132416., 134784., 137152., 139520.,
      93916.,  95656.,  97396.,  99136.,  94456.,  96208.,  97960.,  99712.,
      94996.,  96760.,  98524.,  100288., 95536.,  97312.,  99088.,  100864.,
      96076.,  97864.,  99652.,  101440., 96616.,  98416.,  100216., 102016.,
      97156.,  98968.,  100780., 102592., 97696.,  99520.,  101344., 103168.,
      117755., 119870., 121985., 124100., 118370., 120500., 122630., 124760.,
      118985., 121130., 123275., 125420., 119600., 121760., 123920., 126080.,
      151740., 154560., 157380., 160200., 152520., 155360., 158200., 161040.,
      153300., 156160., 159020., 161880., 154080., 156960., 159840., 162720.,
      154860., 157760., 160660., 163560., 155640., 158560., 161480., 164400.,
      156420., 159360., 162300., 165240., 157200., 160160., 163120., 166080.,
      111515., 113690., 115865., 118040., 112070., 114260., 116450., 118640.,
      112625., 114830., 117035., 119240., 113180., 115400., 117620., 119840.,
      113735., 115970., 118205., 120440., 114290., 116540., 118790., 121040.,
      114845., 117110., 119375., 121640., 115400., 117680., 119960., 122240.,
      137435., 140030., 142625., 145220., 138050., 140660., 143270., 145880.,
      138665., 141290., 143915., 146540., 139280., 141920., 144560., 147200.,
      176700., 180160., 183620., 187080., 177480., 180960., 184440., 187920.,
      178260., 181760., 185260., 188760., 179040., 182560., 186080., 189600.,
      179820., 183360., 186900., 190440., 180600., 184160., 187720., 191280.,
      181380., 184960., 188540., 192120., 182160., 185760., 189360., 192960.,
      129275., 131930., 134585., 137240., 129830., 132500., 135170., 137840.,
      130385., 133070., 135755., 138440., 130940., 133640., 136340., 139040.,
      131495., 134210., 136925., 139640., 132050., 134780., 137510., 140240.,
      132605., 135350., 138095., 140840., 133160., 135920., 138680., 141440.,
      84124.,  86200.,  88276.,  90352.,  84520.,  86608.,  88696.,  90784.,
      84916.,  87016.,  89116.,  91216.,  85312.,  87424.,  89536.,  91648.,
      106928., 109696., 112464., 115232., 107424., 110208., 112992., 115776.,
      107920., 110720., 113520., 116320., 108416., 111232., 114048., 116864.,
      108912., 111744., 114576., 117408., 109408., 112256., 115104., 117952.,
      109904., 112768., 115632., 118496., 110400., 113280., 116160., 119040.,
      77212.,  79336.,  81460.,  83584.,  77560.,  79696.,  81832.,  83968.,
      77908.,  80056.,  82204.,  84352.,  78256.,  80416.,  82576.,  84736.,
      78604.,  80776.,  82948.,  85120.,  78952.,  81136.,  83320.,  85504.,
      79300.,  81496.,  83692.,  85888.,  79648.,  81856.,  84064.,  86272.,
      96796.,  99256.,  101716., 104176., 97192.,  99664.,  102136., 104608.,
      97588.,  100072., 102556., 105040., 97984.,  100480., 102976., 105472.,
      122800., 126080., 129360., 132640., 123296., 126592., 129888., 133184.,
      123792., 127104., 130416., 133728., 124288., 127616., 130944., 134272.,
      124784., 128128., 131472., 134816., 125280., 128640., 132000., 135360.,
      125776., 129152., 132528., 135904., 126272., 129664., 133056., 136448.,
      88348.,  90856.,  93364.,  95872.,  88696.,  91216.,  93736.,  96256.,
      89044.,  91576.,  94108.,  96640.,  89392.,  91936.,  94480.,  97024.,
      89740.,  92296.,  94852.,  97408.,  90088.,  92656.,  95224.,  97792.,
      90436.,  93016.,  95596.,  98176.,  90784.,  93376.,  95968.,  98560.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6650.,  7064.,  7478.,  7892.,  6716.,  7136.,  7556.,  7976.,  6782.,
      7208.,  7634.,  8060.,  6848.,  7280.,  7712.,  8144.,  6914.,  7352.,
      7790.,  8228.,  6980.,  7424.,  7868.,  8312.,  7046.,  7496.,  7946.,
      8396.,  7112.,  7568.,  8024.,  8480.,  7178.,  7640.,  8102.,  8564.,
      7244.,  7712.,  8180.,  8648.,  7310.,  7784.,  8258.,  8732.,  7376.,
      7856.,  8336.,  8816.,  7442.,  7928.,  8414.,  8900.,  7508.,  8000.,
      8492.,  8984.,  7574.,  8072.,  8570.,  9068.,  7640.,  8144.,  8648.,
      9152.,  7706.,  8216.,  8726.,  9236.,  7772.,  8288.,  8804.,  9320.,
      7838.,  8360.,  8882.,  9404.,  7904.,  8432.,  8960.,  9488.,  8762.,
      9368.,  9974.,  10580., 8828.,  9440.,  10052., 10664., 8894.,  9512.,
      10130., 10748., 8960.,  9584.,  10208., 10832., 9026.,  9656.,  10286.,
      10916., 9092.,  9728.,  10364., 11000., 9158.,  9800.,  10442., 11084.,
      9224.,  9872.,  10520., 11168., 9290.,  9944.,  10598., 11252., 9356.,
      10016., 10676., 11336., 9422.,  10088., 10754., 11420., 9488.,  10160.,
      10832., 11504., 9554.,  10232., 10910., 11588., 9620.,  10304., 10988.,
      11672., 9686.,  10376., 11066., 11756., 9752.,  10448., 11144., 11840.,
      9818.,  10520., 11222., 11924., 9884.,  10592., 11300., 12008., 9950.,
      10664., 11378., 12092., 10016., 10736., 11456., 12176., 10874., 11672.,
      12470., 13268., 10940., 11744., 12548., 13352., 11006., 11816., 12626.,
      13436., 11072., 11888., 12704., 13520., 11138., 11960., 12782., 13604.,
      11204., 12032., 12860., 13688., 11270., 12104., 12938., 13772., 11336.,
      12176., 13016., 13856., 11402., 12248., 13094., 13940., 11468., 12320.,
      13172., 14024., 11534., 12392., 13250., 14108., 11600., 12464., 13328.,
      14192., 11666., 12536., 13406., 14276., 11732., 12608., 13484., 14360.,
      11798., 12680., 13562., 14444., 11864., 12752., 13640., 14528., 11930.,
      12824., 13718., 14612., 11996., 12896., 13796., 14696., 12062., 12968.,
      13874., 14780., 12128., 13040., 13952., 14864., 12986., 13976., 14966.,
      15956., 13052., 14048., 15044., 16040., 13118., 14120., 15122., 16124.,
      13184., 14192., 15200., 16208., 13250., 14264., 15278., 16292., 13316.,
      14336., 15356., 16376., 13382., 14408., 15434., 16460., 13448., 14480.,
      15512., 16544., 13514., 14552., 15590., 16628., 13580., 14624., 15668.,
      16712., 13646., 14696., 15746., 16796., 13712., 14768., 15824., 16880.,
      13778., 14840., 15902., 16964., 13844., 14912., 15980., 17048., 13910.,
      14984., 16058., 17132., 13976., 15056., 16136., 17216., 14042., 15128.,
      16214., 17300., 14108., 15200., 16292., 17384., 14174., 15272., 16370.,
      17468., 14240., 15344., 16448., 17552., 15098., 16280., 17462., 18644.,
      15164., 16352., 17540., 18728., 15230., 16424., 17618., 18812., 15296.,
      16496., 17696., 18896., 15362., 16568., 17774., 18980., 15428., 16640.,
      17852., 19064., 15494., 16712., 17930., 19148., 15560., 16784., 18008.,
      19232., 15626., 16856., 18086., 19316., 15692., 16928., 18164., 19400.,
      15758., 17000., 18242., 19484., 15824., 17072., 18320., 19568., 15890.,
      17144., 18398., 19652., 15956., 17216., 18476., 19736., 16022., 17288.,
      18554., 19820., 16088., 17360., 18632., 19904., 16154., 17432., 18710.,
      19988., 16220., 17504., 18788., 20072., 16286., 17576., 18866., 20156.,
      16352., 17648., 18944., 20240.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13560., 16530., 16840., 13080., 13320., 16200., 19725., 20050., 15550.,
      15800., 18900., 22975., 23300., 18050., 18300., 11720., 14130., 14340.,
      11000., 11160., 13480., 16230., 16440., 12600., 12760.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1407., 1452., 1497., 1542., 1587., 1857., 1902., 1947., 1992.,
      2037., 2307., 2352., 2397., 2442., 2487., 2757., 2802., 2847.,
      2892., 2937., 3207., 3252., 3297., 3342., 3387.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26400., 27120., 32160., 33060., 32760., 33680., 25424., 26160., 25888.,
      26640., 31500., 32400., 38325., 39450., 38950., 40100., 30180., 31100.,
      30660., 31600., 36700., 37800., 44575., 45950., 45200., 46600., 34980.,
      36100., 35460., 36600., 22560., 23440., 27160., 28260., 27560., 28680.,
      21104., 22000., 21408., 22320., 25920., 26960., 31160., 32460., 31560.,
      32880., 24144., 25200., 24448., 25520.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2607., 2814., 2688., 2904., 2769., 2994., 2850., 3084., 2931., 3174.,
      3417., 3714., 3498., 3804., 3579., 3894., 3660., 3984., 3741., 4074.,
      4227., 4614., 4308., 4704., 4389., 4794., 4470., 4884., 4551., 4974.,
      5037., 5514., 5118., 5604., 5199., 5694., 5280., 5784., 5361., 5874.,
      5847., 6414., 5928., 6504., 6009., 6594., 6090., 6684., 6171., 6774.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52080., 52800., 53520., 54240., 63420., 64320., 65220., 66120., 64600.,
      65520., 66440., 67360., 50112., 50848., 51584., 52320., 51024., 51776.,
      52528., 53280., 62100., 63000., 63900., 64800., 75525., 76650., 77775.,
      78900., 76750., 77900., 79050., 80200., 59440., 60360., 61280., 62200.,
      60380., 61320., 62260., 63200., 72300., 73400., 74500., 75600., 87775.,
      89150., 90525., 91900., 89000., 90400., 91800., 93200., 68840., 69960.,
      71080., 72200., 69780., 70920., 72060., 73200., 44240., 45120., 46000.,
      46880., 53220., 54320., 55420., 56520., 54000., 55120., 56240., 57360.,
      41312., 42208., 43104., 44000., 41904., 42816., 43728., 44640., 50800.,
      51840., 52880., 53920., 61020., 62320., 63620., 64920., 61800., 63120.,
      64440., 65760., 47232., 48288., 49344., 50400., 47824., 48896., 49968.,
      51040.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5007.,  5214.,  5421.,  5628.,  5160.,  5376.,  5592.,  5808.,  5313.,
      5538.,  5763.,  5988.,  5466.,  5700.,  5934.,  6168.,  5619.,  5862.,
      6105.,  6348.,  6537.,  6834.,  7131.,  7428.,  6690.,  6996.,  7302.,
      7608.,  6843.,  7158.,  7473.,  7788.,  6996.,  7320.,  7644.,  7968.,
      7149.,  7482.,  7815.,  8148.,  8067.,  8454.,  8841.,  9228.,  8220.,
      8616.,  9012.,  9408.,  8373.,  8778.,  9183.,  9588.,  8526.,  8940.,
      9354.,  9768.,  8679.,  9102.,  9525.,  9948.,  9597.,  10074., 10551.,
      11028., 9750.,  10236., 10722., 11208., 9903.,  10398., 10893., 11388.,
      10056., 10560., 11064., 11568., 10209., 10722., 11235., 11748., 11127.,
      11694., 12261., 12828., 11280., 11856., 12432., 13008., 11433., 12018.,
      12603., 13188., 11586., 12180., 12774., 13368., 11739., 12342., 12945.,
      13548.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26864., 27120., 32750., 33060., 33370., 33680., 25920., 26160., 26400.,
      26640., 32130., 32400., 39125., 39450., 39775., 40100., 30850., 31100.,
      31350., 31600., 37530., 37800., 45625., 45950., 46275., 46600., 35850.,
      36100., 36350., 36600., 23264., 23440., 28050., 28260., 28470., 28680.,
      21840., 22000., 22160., 22320., 26784., 26960., 32250., 32460., 32670.,
      32880., 25040., 25200., 25360., 25520.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2769., 2814., 2859., 2904., 2949., 2994., 3039., 3084., 3129., 3174.,
      3669., 3714., 3759., 3804., 3849., 3894., 3939., 3984., 4029., 4074.,
      4569., 4614., 4659., 4704., 4749., 4794., 4839., 4884., 4929., 4974.,
      5469., 5514., 5559., 5604., 5649., 5694., 5739., 5784., 5829., 5874.,
      6369., 6414., 6459., 6504., 6549., 6594., 6639., 6684., 6729., 6774.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52304., 53728., 52800., 54240., 63720., 65500., 64320., 66120., 64920.,
      66740., 65520., 67360., 50384., 51840., 50848., 52320., 51312., 52800.,
      51776., 53280., 62480., 64260., 63000., 64800., 76025., 78250., 76650.,
      78900., 77275., 79550., 77900., 80200., 59880., 61700., 60360., 62200.,
      60840., 62700., 61320., 63200., 72880., 75060., 73400., 75600., 88525.,
      91250., 89150., 91900., 89775., 92550., 90400., 93200., 69480., 71700.,
      69960., 72200., 70440., 72700., 70920., 73200., 44784., 46528., 45120.,
      46880., 53920., 56100., 54320., 56520., 54720., 56940., 55120., 57360.,
      41904., 43680., 42208., 44000., 42512., 44320., 42816., 44640., 51504.,
      53568., 51840., 53920., 61920., 64500., 62320., 64920., 62720., 65340.,
      63120., 65760., 47984., 50080., 48288., 50400., 48592., 50720., 48896.,
      51040.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5133.,  5538.,  5214.,  5628.,  5295.,  5718.,  5376.,  5808.,  5457.,
      5898.,  5538.,  5988.,  5619.,  6078.,  5700.,  6168.,  5781.,  6258.,
      5862.,  6348.,  6753.,  7338.,  6834.,  7428.,  6915.,  7518.,  6996.,
      7608.,  7077.,  7698.,  7158.,  7788.,  7239.,  7878.,  7320.,  7968.,
      7401.,  8058.,  7482.,  8148.,  8373.,  9138.,  8454.,  9228.,  8535.,
      9318.,  8616.,  9408.,  8697.,  9498.,  8778.,  9588.,  8859.,  9678.,
      8940.,  9768.,  9021.,  9858.,  9102.,  9948.,  9993.,  10938., 10074.,
      11028., 10155., 11118., 10236., 11208., 10317., 11298., 10398., 11388.,
      10479., 11478., 10560., 11568., 10641., 11658., 10722., 11748., 11613.,
      12738., 11694., 12828., 11775., 12918., 11856., 13008., 11937., 13098.,
      12018., 13188., 12099., 13278., 12180., 13368., 12261., 13458., 12342.,
      13548.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      103184., 104608., 106032., 107456., 104160., 105600., 107040., 108480.,
      125660., 127440., 129220., 131000., 126840., 128640., 130440., 132240.,
      128020., 129840., 131660., 133480., 129200., 131040., 132880., 134720.,
      99312.,  100768., 102224., 103680., 100224., 101696., 103168., 104640.,
      101136., 102624., 104112., 105600., 102048., 103552., 105056., 106560.,
      123180., 124960., 126740., 128520., 124200., 126000., 127800., 129600.,
      149825., 152050., 154275., 156500., 151050., 153300., 155550., 157800.,
      152275., 154550., 156825., 159100., 153500., 155800., 158100., 160400.,
      117940., 119760., 121580., 123400., 118880., 120720., 122560., 124400.,
      119820., 121680., 123540., 125400., 120760., 122640., 124520., 126400.,
      143580., 145760., 147940., 150120., 144600., 146800., 149000., 151200.,
      174325., 177050., 179775., 182500., 175550., 178300., 181050., 183800.,
      176775., 179550., 182325., 185100., 178000., 180800., 183600., 186400.,
      136740., 138960., 141180., 143400., 137680., 139920., 142160., 144400.,
      138620., 140880., 143140., 145400., 139560., 141840., 144120., 146400.,
      87824.,  89568.,  91312.,  93056.,  88480.,  90240.,  92000.,  93760.,
      105660., 107840., 110020., 112200., 106440., 108640., 110840., 113040.,
      107220., 109440., 111660., 113880., 108000., 110240., 112480., 114720.,
      82032.,  83808.,  85584.,  87360.,  82624.,  84416.,  86208.,  88000.,
      83216.,  85024.,  86832.,  88640.,  83808.,  85632.,  87456.,  89280.,
      100944., 103008., 105072., 107136., 101600., 103680., 105760., 107840.,
      121260., 123840., 126420., 129000., 122040., 124640., 127240., 129840.,
      122820., 125440., 128060., 130680., 123600., 126240., 128880., 131520.,
      93872.,  95968.,  98064.,  100160., 94464.,  96576.,  98688.,  100800.,
      95056.,  97184.,  99312.,  101440., 95648.,  97792.,  99936.,  102080.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9861.,  10266., 10671., 11076., 10014., 10428., 10842., 11256., 10167.,
      10590., 11013., 11436., 10320., 10752., 11184., 11616., 10473., 10914.,
      11355., 11796., 10626., 11076., 11526., 11976., 10779., 11238., 11697.,
      12156., 10932., 11400., 11868., 12336., 11085., 11562., 12039., 12516.,
      11238., 11724., 12210., 12696., 12921., 13506., 14091., 14676., 13074.,
      13668., 14262., 14856., 13227., 13830., 14433., 15036., 13380., 13992.,
      14604., 15216., 13533., 14154., 14775., 15396., 13686., 14316., 14946.,
      15576., 13839., 14478., 15117., 15756., 13992., 14640., 15288., 15936.,
      14145., 14802., 15459., 16116., 14298., 14964., 15630., 16296., 15981.,
      16746., 17511., 18276., 16134., 16908., 17682., 18456., 16287., 17070.,
      17853., 18636., 16440., 17232., 18024., 18816., 16593., 17394., 18195.,
      18996., 16746., 17556., 18366., 19176., 16899., 17718., 18537., 19356.,
      17052., 17880., 18708., 19536., 17205., 18042., 18879., 19716., 17358.,
      18204., 19050., 19896., 19041., 19986., 20931., 21876., 19194., 20148.,
      21102., 22056., 19347., 20310., 21273., 22236., 19500., 20472., 21444.,
      22416., 19653., 20634., 21615., 22596., 19806., 20796., 21786., 22776.,
      19959., 20958., 21957., 22956., 20112., 21120., 22128., 23136., 20265.,
      21282., 22299., 23316., 20418., 21444., 22470., 23496., 22101., 23226.,
      24351., 25476., 22254., 23388., 24522., 25656., 22407., 23550., 24693.,
      25836., 22560., 23712., 24864., 26016., 22713., 23874., 25035., 26196.,
      22866., 24036., 25206., 26376., 23019., 24198., 25377., 26556., 23172.,
      24360., 25548., 26736., 23325., 24522., 25719., 26916., 23478., 24684.,
      25890., 27096.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      53472., 53728., 53984., 54240., 65190., 65500., 65810., 66120., 66430.,
      66740., 67050., 67360., 51600., 51840., 52080., 52320., 52560., 52800.,
      53040., 53280., 63990., 64260., 64530., 64800., 77925., 78250., 78575.,
      78900., 79225., 79550., 79875., 80200., 61450., 61700., 61950., 62200.,
      62450., 62700., 62950., 63200., 74790., 75060., 75330., 75600., 90925.,
      91250., 91575., 91900., 92225., 92550., 92875., 93200., 71450., 71700.,
      71950., 72200., 72450., 72700., 72950., 73200., 46352., 46528., 46704.,
      46880., 55890., 56100., 56310., 56520., 56730., 56940., 57150., 57360.,
      43520., 43680., 43840., 44000., 44160., 44320., 44480., 44640., 53392.,
      53568., 53744., 53920., 64290., 64500., 64710., 64920., 65130., 65340.,
      65550., 65760., 49920., 50080., 50240., 50400., 50560., 50720., 50880.,
      51040.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5493.,  5538.,  5583.,  5628.,  5673.,  5718.,  5763.,  5808.,  5853.,
      5898.,  5943.,  5988.,  6033.,  6078.,  6123.,  6168.,  6213.,  6258.,
      6303.,  6348.,  7293.,  7338.,  7383.,  7428.,  7473.,  7518.,  7563.,
      7608.,  7653.,  7698.,  7743.,  7788.,  7833.,  7878.,  7923.,  7968.,
      8013.,  8058.,  8103.,  8148.,  9093.,  9138.,  9183.,  9228.,  9273.,
      9318.,  9363.,  9408.,  9453.,  9498.,  9543.,  9588.,  9633.,  9678.,
      9723.,  9768.,  9813.,  9858.,  9903.,  9948.,  10893., 10938., 10983.,
      11028., 11073., 11118., 11163., 11208., 11253., 11298., 11343., 11388.,
      11433., 11478., 11523., 11568., 11613., 11658., 11703., 11748., 12693.,
      12738., 12783., 12828., 12873., 12918., 12963., 13008., 13053., 13098.,
      13143., 13188., 13233., 13278., 13323., 13368., 13413., 13458., 13503.,
      13548.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      104112., 106944., 104608., 107456., 105104., 107968., 105600., 108480.,
      126840., 130380., 127440., 131000., 128040., 131620., 128640., 132240.,
      129240., 132860., 129840., 133480., 130440., 134100., 131040., 134720.,
      100304., 103200., 100768., 103680., 101232., 104160., 101696., 104640.,
      102160., 105120., 102624., 105600., 103088., 106080., 103552., 106560.,
      124440., 127980., 124960., 128520., 125480., 129060., 126000., 129600.,
      151425., 155850., 152050., 156500., 152675., 157150., 153300., 157800.,
      153925., 158450., 154550., 159100., 155175., 159750., 155800., 160400.,
      119280., 122900., 119760., 123400., 120240., 123900., 120720., 124400.,
      121200., 124900., 121680., 125400., 122160., 125900., 122640., 126400.,
      145240., 149580., 145760., 150120., 146280., 150660., 146800., 151200.,
      176425., 181850., 177050., 182500., 177675., 183150., 178300., 183800.,
      178925., 184450., 179550., 185100., 180175., 185750., 180800., 186400.,
      138480., 142900., 138960., 143400., 139440., 143900., 139920., 144400.,
      140400., 144900., 140880., 145400., 141360., 145900., 141840., 146400.,
      89232.,  92704.,  89568.,  93056.,  89904.,  93408.,  90240.,  93760.,
      107440., 111780., 107840., 112200., 108240., 112620., 108640., 113040.,
      109040., 113460., 109440., 113880., 109840., 114300., 110240., 114720.,
      83504.,  87040.,  83808.,  87360.,  84112.,  87680.,  84416.,  88000.,
      84720.,  88320.,  85024.,  88640.,  85328.,  88960.,  85632.,  89280.,
      102672., 106784., 103008., 107136., 103344., 107488., 103680., 107840.,
      123440., 128580., 123840., 129000., 124240., 129420., 124640., 129840.,
      125040., 130260., 125440., 130680., 125840., 131100., 126240., 131520.,
      95664.,  99840.,  95968.,  100160., 96272.,  100480., 96576.,  100800.,
      96880.,  101120., 97184.,  101440., 97488.,  101760., 97792.,  102080.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10185., 10986., 10266., 11076., 10347., 11166., 10428., 11256., 10509.,
      11346., 10590., 11436., 10671., 11526., 10752., 11616., 10833., 11706.,
      10914., 11796., 10995., 11886., 11076., 11976., 11157., 12066., 11238.,
      12156., 11319., 12246., 11400., 12336., 11481., 12426., 11562., 12516.,
      11643., 12606., 11724., 12696., 13425., 14586., 13506., 14676., 13587.,
      14766., 13668., 14856., 13749., 14946., 13830., 15036., 13911., 15126.,
      13992., 15216., 14073., 15306., 14154., 15396., 14235., 15486., 14316.,
      15576., 14397., 15666., 14478., 15756., 14559., 15846., 14640., 15936.,
      14721., 16026., 14802., 16116., 14883., 16206., 14964., 16296., 16665.,
      18186., 16746., 18276., 16827., 18366., 16908., 18456., 16989., 18546.,
      17070., 18636., 17151., 18726., 17232., 18816., 17313., 18906., 17394.,
      18996., 17475., 19086., 17556., 19176., 17637., 19266., 17718., 19356.,
      17799., 19446., 17880., 19536., 17961., 19626., 18042., 19716., 18123.,
      19806., 18204., 19896., 19905., 21786., 19986., 21876., 20067., 21966.,
      20148., 22056., 20229., 22146., 20310., 22236., 20391., 22326., 20472.,
      22416., 20553., 22506., 20634., 22596., 20715., 22686., 20796., 22776.,
      20877., 22866., 20958., 22956., 21039., 23046., 21120., 23136., 21201.,
      23226., 21282., 23316., 21363., 23406., 21444., 23496., 23145., 25386.,
      23226., 25476., 23307., 25566., 23388., 25656., 23469., 25746., 23550.,
      25836., 23631., 25926., 23712., 26016., 23793., 26106., 23874., 26196.,
      23955., 26286., 24036., 26376., 24117., 26466., 24198., 26556., 24279.,
      26646., 24360., 26736., 24441., 26826., 24522., 26916., 24603., 27006.,
      24684., 27096.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME1x10x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      205392., 208224., 211056., 213888., 206368., 209216., 212064., 214912.,
      207344., 210208., 213072., 215936., 208320., 211200., 214080., 216960.,
      250140., 253680., 257220., 260760., 251320., 254880., 258440., 262000.,
      252500., 256080., 259660., 263240., 253680., 257280., 260880., 264480.,
      254860., 258480., 262100., 265720., 256040., 259680., 263320., 266960.,
      257220., 260880., 264540., 268200., 258400., 262080., 265760., 269440.,
      197712., 200608., 203504., 206400., 198624., 201536., 204448., 207360.,
      199536., 202464., 205392., 208320., 200448., 203392., 206336., 209280.,
      201360., 204320., 207280., 210240., 202272., 205248., 208224., 211200.,
      203184., 206176., 209168., 212160., 204096., 207104., 210112., 213120.,
      245340., 248880., 252420., 255960., 246360., 249920., 253480., 257040.,
      247380., 250960., 254540., 258120., 248400., 252000., 255600., 259200.,
      298425., 302850., 307275., 311700., 299650., 304100., 308550., 313000.,
      300875., 305350., 309825., 314300., 302100., 306600., 311100., 315600.,
      303325., 307850., 312375., 316900., 304550., 309100., 313650., 318200.,
      305775., 310350., 314925., 319500., 307000., 311600., 316200., 320800.,
      234940., 238560., 242180., 245800., 235880., 239520., 243160., 246800.,
      236820., 240480., 244140., 247800., 237760., 241440., 245120., 248800.,
      238700., 242400., 246100., 249800., 239640., 243360., 247080., 250800.,
      240580., 244320., 248060., 251800., 241520., 245280., 249040., 252800.,
      286140., 290480., 294820., 299160., 287160., 291520., 295880., 300240.,
      288180., 292560., 296940., 301320., 289200., 293600., 298000., 302400.,
      347425., 352850., 358275., 363700., 348650., 354100., 359550., 365000.,
      349875., 355350., 360825., 366300., 351100., 356600., 362100., 367600.,
      352325., 357850., 363375., 368900., 353550., 359100., 364650., 370200.,
      354775., 360350., 365925., 371500., 356000., 361600., 367200., 372800.,
      272540., 276960., 281380., 285800., 273480., 277920., 282360., 286800.,
      274420., 278880., 283340., 287800., 275360., 279840., 284320., 288800.,
      276300., 280800., 285300., 289800., 277240., 281760., 286280., 290800.,
      278180., 282720., 287260., 291800., 279120., 283680., 288240., 292800.,
      174992., 178464., 181936., 185408., 175648., 179136., 182624., 186112.,
      176304., 179808., 183312., 186816., 176960., 180480., 184000., 187520.,
      210540., 214880., 219220., 223560., 211320., 215680., 220040., 224400.,
      212100., 216480., 220860., 225240., 212880., 217280., 221680., 226080.,
      213660., 218080., 222500., 226920., 214440., 218880., 223320., 227760.,
      215220., 219680., 224140., 228600., 216000., 220480., 224960., 229440.,
      163472., 167008., 170544., 174080., 164064., 167616., 171168., 174720.,
      164656., 168224., 171792., 175360., 165248., 168832., 172416., 176000.,
      165840., 169440., 173040., 176640., 166432., 170048., 173664., 177280.,
      167024., 170656., 174288., 177920., 167616., 171264., 174912., 178560.,
      201232., 205344., 209456., 213568., 201888., 206016., 210144., 214272.,
      202544., 206688., 210832., 214976., 203200., 207360., 211520., 215680.,
      241740., 246880., 252020., 257160., 242520., 247680., 252840., 258000.,
      243300., 248480., 253660., 258840., 244080., 249280., 254480., 259680.,
      244860., 250080., 255300., 260520., 245640., 250880., 256120., 261360.,
      246420., 251680., 256940., 262200., 247200., 252480., 257760., 263040.,
      187152., 191328., 195504., 199680., 187744., 191936., 196128., 200320.,
      188336., 192544., 196752., 200960., 188928., 193152., 197376., 201600.,
      189520., 193760., 198000., 202240., 190112., 194368., 198624., 202880.,
      190704., 194976., 199248., 203520., 191296., 195584., 199872., 204160.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID1x10x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19569., 20370., 21171., 21972., 19722., 20532., 21342., 22152., 19875.,
      20694., 21513., 22332., 20028., 20856., 21684., 22512., 20181., 21018.,
      21855., 22692., 20334., 21180., 22026., 22872., 20487., 21342., 22197.,
      23052., 20640., 21504., 22368., 23232., 20793., 21666., 22539., 23412.,
      20946., 21828., 22710., 23592., 21099., 21990., 22881., 23772., 21252.,
      22152., 23052., 23952., 21405., 22314., 23223., 24132., 21558., 22476.,
      23394., 24312., 21711., 22638., 23565., 24492., 21864., 22800., 23736.,
      24672., 22017., 22962., 23907., 24852., 22170., 23124., 24078., 25032.,
      22323., 23286., 24249., 25212., 22476., 23448., 24420., 25392., 25689.,
      26850., 28011., 29172., 25842., 27012., 28182., 29352., 25995., 27174.,
      28353., 29532., 26148., 27336., 28524., 29712., 26301., 27498., 28695.,
      29892., 26454., 27660., 28866., 30072., 26607., 27822., 29037., 30252.,
      26760., 27984., 29208., 30432., 26913., 28146., 29379., 30612., 27066.,
      28308., 29550., 30792., 27219., 28470., 29721., 30972., 27372., 28632.,
      29892., 31152., 27525., 28794., 30063., 31332., 27678., 28956., 30234.,
      31512., 27831., 29118., 30405., 31692., 27984., 29280., 30576., 31872.,
      28137., 29442., 30747., 32052., 28290., 29604., 30918., 32232., 28443.,
      29766., 31089., 32412., 28596., 29928., 31260., 32592., 31809., 33330.,
      34851., 36372., 31962., 33492., 35022., 36552., 32115., 33654., 35193.,
      36732., 32268., 33816., 35364., 36912., 32421., 33978., 35535., 37092.,
      32574., 34140., 35706., 37272., 32727., 34302., 35877., 37452., 32880.,
      34464., 36048., 37632., 33033., 34626., 36219., 37812., 33186., 34788.,
      36390., 37992., 33339., 34950., 36561., 38172., 33492., 35112., 36732.,
      38352., 33645., 35274., 36903., 38532., 33798., 35436., 37074., 38712.,
      33951., 35598., 37245., 38892., 34104., 35760., 37416., 39072., 34257.,
      35922., 37587., 39252., 34410., 36084., 37758., 39432., 34563., 36246.,
      37929., 39612., 34716., 36408., 38100., 39792., 37929., 39810., 41691.,
      43572., 38082., 39972., 41862., 43752., 38235., 40134., 42033., 43932.,
      38388., 40296., 42204., 44112., 38541., 40458., 42375., 44292., 38694.,
      40620., 42546., 44472., 38847., 40782., 42717., 44652., 39000., 40944.,
      42888., 44832., 39153., 41106., 43059., 45012., 39306., 41268., 43230.,
      45192., 39459., 41430., 43401., 45372., 39612., 41592., 43572., 45552.,
      39765., 41754., 43743., 45732., 39918., 41916., 43914., 45912., 40071.,
      42078., 44085., 46092., 40224., 42240., 44256., 46272., 40377., 42402.,
      44427., 46452., 40530., 42564., 44598., 46632., 40683., 42726., 44769.,
      46812., 40836., 42888., 44940., 46992., 44049., 46290., 48531., 50772.,
      44202., 46452., 48702., 50952., 44355., 46614., 48873., 51132., 44508.,
      46776., 49044., 51312., 44661., 46938., 49215., 51492., 44814., 47100.,
      49386., 51672., 44967., 47262., 49557., 51852., 45120., 47424., 49728.,
      52032., 45273., 47586., 49899., 52212., 45426., 47748., 50070., 52392.,
      45579., 47910., 50241., 52572., 45732., 48072., 50412., 52752., 45885.,
      48234., 50583., 52932., 46038., 48396., 50754., 53112., 46191., 48558.,
      50925., 53292., 46344., 48720., 51096., 53472., 46497., 48882., 51267.,
      53652., 46650., 49044., 51438., 53832., 46803., 49206., 51609., 54012.,
      46956., 49368., 51780., 54192.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63270., 63999., 84168., 62190.,  62892., 68373., 69102., 90846., 67104.,
      67806., 87084., 87984., 115592., 85320., 86184., 60489., 61110., 80190.,
      59112., 59706., 64836., 65457.,  85860., 63270., 63864.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6182., 6260., 6338., 6416., 6494., 6728., 6806., 6884., 6962.,
      7040., 7274., 7352., 7430., 7508., 7586., 7820., 7898., 7976.,
      8054., 8132., 8366., 8444., 8522., 8600., 8678.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      124758., 126540., 126189., 127998., 165924., 168336., 122571., 124380.,
      123948., 125784., 134775., 136746., 136206., 138204., 179028., 181692.,
      132210., 134208., 133587., 135612., 171540., 174168., 173304., 175968.,
      227632., 231184., 167976., 170640., 169668., 172368., 119007., 120978.,
      120222., 122220., 157716., 160380., 116226., 118224., 117387., 119412.,
      127512., 129672., 128727., 130914., 168804., 171720., 124353., 126540.,
      125514., 127728.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11668., 12364., 11812., 12520., 11956., 12676., 12100., 12832., 12244.,
      12988., 12676., 13456., 12820., 13612., 12964., 13768., 13108., 13924.,
      13252., 14080., 13684., 14548., 13828., 14704., 13972., 14860., 14116.,
      15016., 14260., 15172., 14692., 15640., 14836., 15796., 14980., 15952.,
      15124., 16108., 15268., 16264., 15700., 16732., 15844., 16888., 15988.,
      17044., 16132., 17200., 16276., 17356.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      247734., 249516., 251298., 253080., 250569., 252378., 254187., 255996.,
      329436., 331848., 334260., 336672., 243333., 245142., 246951., 248760.,
      246060., 247896., 249732., 251568., 267579., 269550., 271521., 273492.,
      270414., 272412., 274410., 276408., 355392., 358056., 360720., 363384.,
      262422., 264420., 266418., 268416., 265149., 267174., 269199., 271224.,
      340452., 343080., 345708., 348336., 343944., 346608., 349272., 351936.,
      451712., 455264., 458816., 462368., 333288., 335952., 338616., 341280.,
      336636., 339336., 342036., 344736., 236043., 238014., 239985., 241956.,
      238446., 240444., 242442., 244440., 312768., 315432., 318096., 320760.,
      230454., 232452., 234450., 236448., 232749., 234774., 236799., 238824.,
      252864., 255024., 257184., 259344., 255267., 257454., 259641., 261828.,
      334692., 337608., 340524., 343440., 246519., 248706., 250893., 253080.,
      248814., 251028., 253242., 255456.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22640., 23336., 24032., 24728., 22916., 23624., 24332., 25040., 23192.,
      23912., 24632., 25352., 23468., 24200., 24932., 25664., 23744., 24488.,
      25232., 25976., 24572., 25352., 26132., 26912., 24848., 25640., 26432.,
      27224., 25124., 25928., 26732., 27536., 25400., 26216., 27032., 27848.,
      25676., 26504., 27332., 28160., 26504., 27368., 28232., 29096., 26780.,
      27656., 28532., 29408., 27056., 27944., 28832., 29720., 27332., 28232.,
      29132., 30032., 27608., 28520., 29432., 30344., 28436., 29384., 30332.,
      31280., 28712., 29672., 30632., 31592., 28988., 29960., 30932., 31904.,
      29264., 30248., 31232., 32216., 29540., 30536., 31532., 32528., 30368.,
      31400., 32432., 33464., 30644., 31688., 32732., 33776., 30920., 31976.,
      33032., 34088., 31196., 32264., 33332., 34400., 31472., 32552., 33632.,
      34712.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      125811., 126540., 127269., 127998., 167382., 168336., 123678., 124380.,
      125082., 125784., 136017., 136746., 137475., 138204., 180738., 181692.,
      133506., 134208., 134910., 135612., 173268., 174168., 175068., 175968.,
      230008., 231184., 169776., 170640., 171504., 172368., 120357., 120978.,
      121599., 122220., 159570., 160380., 117630., 118224., 118818., 119412.,
      129051., 129672., 130293., 130914., 170910., 171720., 125946., 126540.,
      127134., 127728.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12286., 12364., 12442., 12520., 12598., 12676., 12754., 12832., 12910.,
      12988., 13378., 13456., 13534., 13612., 13690., 13768., 13846., 13924.,
      14002., 14080., 14470., 14548., 14626., 14704., 14782., 14860., 14938.,
      15016., 15094., 15172., 15562., 15640., 15718., 15796., 15874., 15952.,
      16030., 16108., 16186., 16264., 16654., 16732., 16810., 16888., 16966.,
      17044., 17122., 17200., 17278., 17356.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      248085., 251622., 249516., 253080., 250947., 254538., 252378., 255996.,
      329976., 334764., 331848., 336672., 243765., 247356., 245142., 248760.,
      246519., 250164., 247896., 251568., 268119., 272034., 269550., 273492.,
      270981., 274950., 272412., 276408., 356184., 361476., 358056., 363384.,
      263043., 267012., 264420., 268416., 265797., 269820., 267174., 271224.,
      341316., 346536., 343080., 348336., 344844., 350136., 346608., 351936.,
      452960., 460016., 455264., 462368., 334260., 339552., 335952., 341280.,
      337644., 343008., 339336., 344736., 236799., 240714., 238014., 241956.,
      239229., 243198., 240444., 244440., 313848., 319140., 315432., 320760.,
      231291., 235260., 232452., 236448., 233613., 237636., 234774., 238824.,
      253809., 258102., 255024., 259344., 256239., 260586., 257454., 261828.,
      336024., 341820., 337608., 343440., 247545., 251892., 248706., 253080.,
      249867., 254268., 251028., 255456.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23192., 24572., 23336., 24728., 23480., 24884., 23624., 25040., 23768.,
      25196., 23912., 25352., 24056., 25508., 24200., 25664., 24344., 25820.,
      24488., 25976., 25208., 26756., 25352., 26912., 25496., 27068., 25640.,
      27224., 25784., 27380., 25928., 27536., 26072., 27692., 26216., 27848.,
      26360., 28004., 26504., 28160., 27224., 28940., 27368., 29096., 27512.,
      29252., 27656., 29408., 27800., 29564., 27944., 29720., 28088., 29876.,
      28232., 30032., 28376., 30188., 28520., 30344., 29240., 31124., 29384.,
      31280., 29528., 31436., 29672., 31592., 29816., 31748., 29960., 31904.,
      30104., 32060., 30248., 32216., 30392., 32372., 30536., 32528., 31256.,
      33308., 31400., 33464., 31544., 33620., 31688., 33776., 31832., 33932.,
      31976., 34088., 32120., 34244., 32264., 34400., 32408., 34556., 32552.,
      34712.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      492633., 496170., 499707., 503244., 495468., 499032., 502596., 506160.,
      498303., 501894., 505485., 509076., 501138., 504756., 508374., 511992.,
      655164., 659952., 664740., 669528., 658872., 663696., 668520., 673344.,
      483939., 487530., 491121., 494712., 486666., 490284., 493902., 497520.,
      489393., 493038., 496683., 500328., 492120., 495792., 499464., 503136.,
      532323., 536238., 540153., 544068., 535158., 539100., 543042., 546984.,
      537993., 541962., 545931., 549900., 540828., 544824., 548820., 552816.,
      707076., 712368., 717660., 722952., 710784., 716112., 721440., 726768.,
      522117., 526086., 530055., 534024., 524844., 528840., 532836., 536832.,
      527571., 531594., 535617., 539640., 530298., 534348., 538398., 542448.,
      677412., 682632., 687852., 693072., 680904., 686160., 691416., 696672.,
      684396., 689688., 694980., 700272., 687888., 693216., 698544., 703872.,
      898864., 905920., 912976., 920032., 903424., 910528., 917632., 924736.,
      663228., 668520., 673812., 679104., 666576., 671904., 677232., 682560.,
      669924., 675288., 680652., 686016., 673272., 678672., 684072., 689472.,
      469683., 473598., 477513., 481428., 472086., 476028., 479970., 483912.,
      474489., 478458., 482427., 486396., 476892., 480888., 484884., 488880.,
      622404., 627696., 632988., 638280., 625536., 630864., 636192., 641520.,
      458613., 462582., 466551., 470520., 460908., 464904., 468900., 472896.,
      463203., 467226., 471249., 475272., 465498., 469548., 473598., 477648.,
      503325., 507618., 511911., 516204., 505728., 510048., 514368., 518688.,
      508131., 512478., 516825., 521172., 510534., 514908., 519282., 523656.,
      666252., 672048., 677844., 683640., 669384., 675216., 681048., 686880.,
      490743., 495090., 499437., 503784., 493038., 497412., 501786., 506160.,
      495333., 499734., 504135., 508536., 497628., 502056., 506484., 510912.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45004., 46384., 47764., 49144., 45280., 46672., 48064., 49456., 45556.,
      46960., 48364., 49768., 45832., 47248., 48664., 50080., 46108., 47536.,
      48964., 50392., 46384., 47824., 49264., 50704., 46660., 48112., 49564.,
      51016., 46936., 48400., 49864., 51328., 47212., 48688., 50164., 51640.,
      47488., 48976., 50464., 51952., 48868., 50416., 51964., 53512., 49144.,
      50704., 52264., 53824., 49420., 50992., 52564., 54136., 49696., 51280.,
      52864., 54448., 49972., 51568., 53164., 54760., 50248., 51856., 53464.,
      55072., 50524., 52144., 53764., 55384., 50800., 52432., 54064., 55696.,
      51076., 52720., 54364., 56008., 51352., 53008., 54664., 56320., 52732.,
      54448., 56164., 57880., 53008., 54736., 56464., 58192., 53284., 55024.,
      56764., 58504., 53560., 55312., 57064., 58816., 53836., 55600., 57364.,
      59128., 54112., 55888., 57664., 59440., 54388., 56176., 57964., 59752.,
      54664., 56464., 58264., 60064., 54940., 56752., 58564., 60376., 55216.,
      57040., 58864., 60688., 56596., 58480., 60364., 62248., 56872., 58768.,
      60664., 62560., 57148., 59056., 60964., 62872., 57424., 59344., 61264.,
      63184., 57700., 59632., 61564., 63496., 57976., 59920., 61864., 63808.,
      58252., 60208., 62164., 64120., 58528., 60496., 62464., 64432., 58804.,
      60784., 62764., 64744., 59080., 61072., 63064., 65056., 60460., 62512.,
      64564., 66616., 60736., 62800., 64864., 66928., 61012., 63088., 65164.,
      67240., 61288., 63376., 65464., 67552., 61564., 63664., 65764., 67864.,
      61840., 63952., 66064., 68176., 62116., 64240., 66364., 68488., 62392.,
      64528., 66664., 68800., 62668., 64816., 66964., 69112., 62944., 65104.,
      67264., 69424.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      250893., 251622., 252351., 253080., 253809., 254538., 255267., 255996.,
      333810., 334764., 335718., 336672., 246654., 247356., 248058., 248760.,
      249462., 250164., 250866., 251568., 271305., 272034., 272763., 273492.,
      274221., 274950., 275679., 276408., 360522., 361476., 362430., 363384.,
      266310., 267012., 267714., 268416., 269118., 269820., 270522., 271224.,
      345636., 346536., 347436., 348336., 349236., 350136., 351036., 351936.,
      458840., 460016., 461192., 462368., 338688., 339552., 340416., 341280.,
      342144., 343008., 343872., 344736., 240093., 240714., 241335., 241956.,
      242577., 243198., 243819., 244440., 318330., 319140., 319950., 320760.,
      234666., 235260., 235854., 236448., 237042., 237636., 238230., 238824.,
      257481., 258102., 258723., 259344., 259965., 260586., 261207., 261828.,
      341010., 341820., 342630., 343440., 251298., 251892., 252486., 253080.,
      253674., 254268., 254862., 255456.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24494., 24572., 24650., 24728., 24806., 24884., 24962., 25040., 25118.,
      25196., 25274., 25352., 25430., 25508., 25586., 25664., 25742., 25820.,
      25898., 25976., 26678., 26756., 26834., 26912., 26990., 27068., 27146.,
      27224., 27302., 27380., 27458., 27536., 27614., 27692., 27770., 27848.,
      27926., 28004., 28082., 28160., 28862., 28940., 29018., 29096., 29174.,
      29252., 29330., 29408., 29486., 29564., 29642., 29720., 29798., 29876.,
      29954., 30032., 30110., 30188., 30266., 30344., 31046., 31124., 31202.,
      31280., 31358., 31436., 31514., 31592., 31670., 31748., 31826., 31904.,
      31982., 32060., 32138., 32216., 32294., 32372., 32450., 32528., 33230.,
      33308., 33386., 33464., 33542., 33620., 33698., 33776., 33854., 33932.,
      34010., 34088., 34166., 34244., 34322., 34400., 34478., 34556., 34634.,
      34712.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      494739., 501786., 496170., 503244., 497601., 504702., 499032., 506160.,
      500463., 507618., 501894., 509076., 503325., 510534., 504756., 511992.,
      658080., 667620., 659952., 669528., 661824., 671436., 663696., 673344.,
      486153., 493308., 487530., 494712., 488907., 496116., 490284., 497520.,
      491661., 498924., 493038., 500328., 494415., 501732., 495792., 503136.,
      534807., 542610., 536238., 544068., 537669., 545526., 539100., 546984.,
      540531., 548442., 541962., 549900., 543393., 551358., 544824., 552816.,
      710496., 721044., 712368., 722952., 714240., 724860., 716112., 726768.,
      524709., 532620., 526086., 534024., 527463., 535428., 528840., 536832.,
      530217., 538236., 531594., 539640., 532971., 541044., 534348., 542448.,
      680868., 691272., 682632., 693072., 684396., 694872., 686160., 696672.,
      687924., 698472., 689688., 700272., 691452., 702072., 693216., 703872.,
      903616., 917680., 905920., 920032., 908224., 922384., 910528., 924736.,
      666828., 677376., 668520., 679104., 670212., 680832., 671904., 682560.,
      673596., 684288., 675288., 686016., 676980., 687744., 678672., 689472.,
      472383., 480186., 473598., 481428., 474813., 482670., 476028., 483912.,
      477243., 485154., 478458., 486396., 479673., 487638., 480888., 488880.,
      626112., 636660., 627696., 638280., 629280., 639900., 630864., 641520.,
      461421., 469332., 462582., 470520., 463743., 471708., 464904., 472896.,
      466065., 474084., 467226., 475272., 468387., 476460., 469548., 477648.,
      506403., 514962., 507618., 516204., 508833., 517446., 510048., 518688.,
      511263., 519930., 512478., 521172., 513693., 522414., 514908., 523656.,
      670464., 682020., 672048., 683640., 673632., 685260., 675216., 686880.,
      493929., 502596., 495090., 503784., 496251., 504972., 497412., 506160.,
      498573., 507348., 499734., 508536., 500895., 509724., 502056., 510912.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46240., 48988., 46384., 49144., 46528., 49300., 46672., 49456., 46816.,
      49612., 46960., 49768., 47104., 49924., 47248., 50080., 47392., 50236.,
      47536., 50392., 47680., 50548., 47824., 50704., 47968., 50860., 48112.,
      51016., 48256., 51172., 48400., 51328., 48544., 51484., 48688., 51640.,
      48832., 51796., 48976., 51952., 50272., 53356., 50416., 53512., 50560.,
      53668., 50704., 53824., 50848., 53980., 50992., 54136., 51136., 54292.,
      51280., 54448., 51424., 54604., 51568., 54760., 51712., 54916., 51856.,
      55072., 52000., 55228., 52144., 55384., 52288., 55540., 52432., 55696.,
      52576., 55852., 52720., 56008., 52864., 56164., 53008., 56320., 54304.,
      57724., 54448., 57880., 54592., 58036., 54736., 58192., 54880., 58348.,
      55024., 58504., 55168., 58660., 55312., 58816., 55456., 58972., 55600.,
      59128., 55744., 59284., 55888., 59440., 56032., 59596., 56176., 59752.,
      56320., 59908., 56464., 60064., 56608., 60220., 56752., 60376., 56896.,
      60532., 57040., 60688., 58336., 62092., 58480., 62248., 58624., 62404.,
      58768., 62560., 58912., 62716., 59056., 62872., 59200., 63028., 59344.,
      63184., 59488., 63340., 59632., 63496., 59776., 63652., 59920., 63808.,
      60064., 63964., 60208., 64120., 60352., 64276., 60496., 64432., 60640.,
      64588., 60784., 64744., 60928., 64900., 61072., 65056., 62368., 66460.,
      62512., 66616., 62656., 66772., 62800., 66928., 62944., 67084., 63088.,
      67240., 63232., 67396., 63376., 67552., 63520., 67708., 63664., 67864.,
      63808., 68020., 63952., 68176., 64096., 68332., 64240., 68488., 64384.,
      68644., 64528., 68800., 64672., 68956., 64816., 69112., 64960., 69268.,
      65104., 69424.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      982431.,  989478.,  996525.,  1003572., 985266.,  992340.,  999414.,
      1006488., 988101.,  995202.,  1002303., 1009404., 990936.,  998064.,
      1005192., 1012320., 993771.,  1000926., 1008081., 1015236., 996606.,
      1003788., 1010970., 1018152., 999441.,  1006650., 1013859., 1021068.,
      1002276., 1009512., 1016748., 1023984., 1306620., 1316160., 1325700.,
      1335240., 1310328., 1319904., 1329480., 1339056., 1314036., 1323648.,
      1333260., 1342872., 1317744., 1327392., 1337040., 1346688., 965151.,
      972306.,  979461.,  986616.,  967878.,  975060.,  982242.,  989424.,
      970605.,  977814.,  985023.,  992232.,  973332.,  980568.,  987804.,
      995040.,  976059.,  983322.,  990585.,  997848.,  978786.,  986076.,
      993366.,  1000656., 981513.,  988830.,  996147.,  1003464., 984240.,
      991584.,  998928.,  1006272., 1061811., 1069614., 1077417., 1085220.,
      1064646., 1072476., 1080306., 1088136., 1067481., 1075338., 1083195.,
      1091052., 1070316., 1078200., 1086084., 1093968., 1073151., 1081062.,
      1088973., 1096884., 1075986., 1083924., 1091862., 1099800., 1078821.,
      1086786., 1094751., 1102716., 1081656., 1089648., 1097640., 1105632.,
      1410444., 1420992., 1431540., 1442088., 1414152., 1424736., 1435320.,
      1445904., 1417860., 1428480., 1439100., 1449720., 1421568., 1432224.,
      1442880., 1453536., 1041507., 1049418., 1057329., 1065240., 1044234.,
      1052172., 1060110., 1068048., 1046961., 1054926., 1062891., 1070856.,
      1049688., 1057680., 1065672., 1073664., 1052415., 1060434., 1068453.,
      1076472., 1055142., 1063188., 1071234., 1079280., 1057869., 1065942.,
      1074015., 1082088., 1060596., 1068696., 1076796., 1084896., 1351332.,
      1361736., 1372140., 1382544., 1354824., 1365264., 1375704., 1386144.,
      1358316., 1368792., 1379268., 1389744., 1361808., 1372320., 1382832.,
      1393344., 1365300., 1375848., 1386396., 1396944., 1368792., 1379376.,
      1389960., 1400544., 1372284., 1382904., 1393524., 1404144., 1375776.,
      1386432., 1397088., 1407744., 1793168., 1807232., 1821296., 1835360.,
      1797728., 1811840., 1825952., 1840064., 1802288., 1816448., 1830608.,
      1844768., 1806848., 1821056., 1835264., 1849472., 1323108., 1333656.,
      1344204., 1354752., 1326456., 1337040., 1347624., 1358208., 1329804.,
      1340424., 1351044., 1361664., 1333152., 1343808., 1354464., 1365120.,
      1336500., 1347192., 1357884., 1368576., 1339848., 1350576., 1361304.,
      1372032., 1343196., 1353960., 1364724., 1375488., 1346544., 1357344.,
      1368144., 1378944., 936963.,  944766.,  952569.,  960372.,  939366.,
      947196.,  955026.,  962856.,  941769.,  949626.,  957483.,  965340.,
      944172.,  952056.,  959940.,  967824.,  946575.,  954486.,  962397.,
      970308.,  948978.,  956916.,  964854.,  972792.,  951381.,  959346.,
      967311.,  975276.,  953784.,  961776.,  969768.,  977760.,  1241676.,
      1252224., 1262772., 1273320., 1244808., 1255392., 1265976., 1276560.,
      1247940., 1258560., 1269180., 1279800., 1251072., 1261728., 1272384.,
      1283040., 914931.,  922842.,  930753.,  938664.,  917226.,  925164.,
      933102.,  941040.,  919521.,  927486.,  935451.,  943416.,  921816.,
      929808.,  937800.,  945792.,  924111.,  932130.,  940149.,  948168.,
      926406.,  934452.,  942498.,  950544.,  928701.,  936774.,  944847.,
      952920.,  930996.,  939096.,  947196.,  955296.,  1004247., 1012806.,
      1021365., 1029924., 1006650., 1015236., 1023822., 1032408., 1009053.,
      1017666., 1026279., 1034892., 1011456., 1020096., 1028736., 1037376.,
      1013859., 1022526., 1031193., 1039860., 1016262., 1024956., 1033650.,
      1042344., 1018665., 1027386., 1036107., 1044828., 1021068., 1029816.,
      1038564., 1047312., 1329372., 1340928., 1352484., 1364040., 1332504.,
      1344096., 1355688., 1367280., 1335636., 1347264., 1358892., 1370520.,
      1338768., 1350432., 1362096., 1373760., 979191.,  987858.,  996525.,
      1005192., 981486.,  990180.,  998874.,  1007568., 983781.,  992502.,
      1001223., 1009944., 986076.,  994824.,  1003572., 1012320., 988371.,
      997146.,  1005921., 1014696., 990666.,  999468.,  1008270., 1017072.,
      992961.,  1001790., 1010619., 1019448., 995256.,  1004112., 1012968.,
      1021824.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89732.,  92480.,  95228.,  97976.,  90008.,  92768.,  95528.,  98288.,
      90284.,  93056.,  95828.,  98600.,  90560.,  93344.,  96128.,  98912.,
      90836.,  93632.,  96428.,  99224.,  91112.,  93920.,  96728.,  99536.,
      91388.,  94208.,  97028.,  99848.,  91664.,  94496.,  97328.,  100160.,
      91940.,  94784.,  97628.,  100472., 92216.,  95072.,  97928.,  100784.,
      92492.,  95360.,  98228.,  101096., 92768.,  95648.,  98528.,  101408.,
      93044.,  95936.,  98828.,  101720., 93320.,  96224.,  99128.,  102032.,
      93596.,  96512.,  99428.,  102344., 93872.,  96800.,  99728.,  102656.,
      94148.,  97088.,  100028., 102968., 94424.,  97376.,  100328., 103280.,
      94700.,  97664.,  100628., 103592., 94976.,  97952.,  100928., 103904.,
      97460.,  100544., 103628., 106712., 97736.,  100832., 103928., 107024.,
      98012.,  101120., 104228., 107336., 98288.,  101408., 104528., 107648.,
      98564.,  101696., 104828., 107960., 98840.,  101984., 105128., 108272.,
      99116.,  102272., 105428., 108584., 99392.,  102560., 105728., 108896.,
      99668.,  102848., 106028., 109208., 99944.,  103136., 106328., 109520.,
      100220., 103424., 106628., 109832., 100496., 103712., 106928., 110144.,
      100772., 104000., 107228., 110456., 101048., 104288., 107528., 110768.,
      101324., 104576., 107828., 111080., 101600., 104864., 108128., 111392.,
      101876., 105152., 108428., 111704., 102152., 105440., 108728., 112016.,
      102428., 105728., 109028., 112328., 102704., 106016., 109328., 112640.,
      105188., 108608., 112028., 115448., 105464., 108896., 112328., 115760.,
      105740., 109184., 112628., 116072., 106016., 109472., 112928., 116384.,
      106292., 109760., 113228., 116696., 106568., 110048., 113528., 117008.,
      106844., 110336., 113828., 117320., 107120., 110624., 114128., 117632.,
      107396., 110912., 114428., 117944., 107672., 111200., 114728., 118256.,
      107948., 111488., 115028., 118568., 108224., 111776., 115328., 118880.,
      108500., 112064., 115628., 119192., 108776., 112352., 115928., 119504.,
      109052., 112640., 116228., 119816., 109328., 112928., 116528., 120128.,
      109604., 113216., 116828., 120440., 109880., 113504., 117128., 120752.,
      110156., 113792., 117428., 121064., 110432., 114080., 117728., 121376.,
      112916., 116672., 120428., 124184., 113192., 116960., 120728., 124496.,
      113468., 117248., 121028., 124808., 113744., 117536., 121328., 125120.,
      114020., 117824., 121628., 125432., 114296., 118112., 121928., 125744.,
      114572., 118400., 122228., 126056., 114848., 118688., 122528., 126368.,
      115124., 118976., 122828., 126680., 115400., 119264., 123128., 126992.,
      115676., 119552., 123428., 127304., 115952., 119840., 123728., 127616.,
      116228., 120128., 124028., 127928., 116504., 120416., 124328., 128240.,
      116780., 120704., 124628., 128552., 117056., 120992., 124928., 128864.,
      117332., 121280., 125228., 129176., 117608., 121568., 125528., 129488.,
      117884., 121856., 125828., 129800., 118160., 122144., 126128., 130112.,
      120644., 124736., 128828., 132920., 120920., 125024., 129128., 133232.,
      121196., 125312., 129428., 133544., 121472., 125600., 129728., 133856.,
      121748., 125888., 130028., 134168., 122024., 126176., 130328., 134480.,
      122300., 126464., 130628., 134792., 122576., 126752., 130928., 135104.,
      122852., 127040., 131228., 135416., 123128., 127328., 131528., 135728.,
      123404., 127616., 131828., 136040., 123680., 127904., 132128., 136352.,
      123956., 128192., 132428., 136664., 124232., 128480., 132728., 136976.,
      124508., 128768., 133028., 137288., 124784., 129056., 133328., 137600.,
      125060., 129344., 133628., 137912., 125336., 129632., 133928., 138224.,
      125612., 129920., 134228., 138536., 125888., 130208., 134528., 138848.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      72720.,  95634., 96588., 71370.,  72072.,  78552.,  103266.,
      104220., 76986., 77688., 100032., 131416., 132592., 97872.,
      98736.,  69480., 91170., 91980.,  67806.,  68400.,  74448.,
      97650.,  98460., 72558., 73152.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7042., 7120., 7198., 7276., 7354., 7666., 7744., 7822., 7900.,
      7978., 8290., 8368., 8446., 8524., 8602., 8914., 8992., 9070.,
      9148., 9226., 9538., 9616., 9694., 9772., 9850.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      143388., 145440., 188532., 191268., 190404., 193176., 140661., 142740.,
      142038., 144144., 154836., 157104., 203508., 206532., 205380., 208440.,
      151677., 153972., 153054., 155376., 197040., 200064., 258800., 262832.,
      261104., 265184., 192684., 195744., 194376., 197472., 136692., 138960.,
      179316., 182340., 180900., 183960., 133317., 135612., 134478., 136800.,
      146412., 148896., 191988., 195300., 193572., 196920., 142605., 145116.,
      143766., 146304.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13292., 14084., 13436., 14240., 13580., 14396., 13724., 14552., 13868.,
      14708., 14444., 15332., 14588., 15488., 14732., 15644., 14876., 15800.,
      15020., 15956., 15596., 16580., 15740., 16736., 15884., 16892., 16028.,
      17048., 16172., 17204., 16748., 17828., 16892., 17984., 17036., 18140.,
      17180., 18296., 17324., 18452., 17900., 19076., 18044., 19232., 18188.,
      19388., 18332., 19544., 18476., 19700.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      284724., 286776., 288828., 290880., 374328., 377064., 379800., 382536.,
      378036., 380808., 383580., 386352., 279243., 281322., 283401., 285480.,
      281970., 284076., 286182., 288288., 307404., 309672., 311940., 314208.,
      403992., 407016., 410040., 413064., 407700., 410760., 413820., 416880.,
      301059., 303354., 305649., 307944., 303786., 306108., 308430., 310752.,
      391056., 394080., 397104., 400128., 513568., 517600., 521632., 525664.,
      518128., 522208., 526288., 530368., 382308., 385368., 388428., 391488.,
      385656., 388752., 391848., 394944., 271116., 273384., 275652., 277920.,
      355608., 358632., 361656., 364680., 358740., 361800., 364860., 367920.,
      264339., 266634., 268929., 271224., 266634., 268956., 271278., 273600.,
      290340., 292824., 295308., 297792., 380664., 383976., 387288., 390600.,
      383796., 387144., 390492., 393840., 282699., 285210., 287721., 290232.,
      284994., 287532., 290070., 292608.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25792., 26584., 27376., 28168., 26068., 26872., 27676., 28480., 26344.,
      27160., 27976., 28792., 26620., 27448., 28276., 29104., 26896., 27736.,
      28576., 29416., 28000., 28888., 29776., 30664., 28276., 29176., 30076.,
      30976., 28552., 29464., 30376., 31288., 28828., 29752., 30676., 31600.,
      29104., 30040., 30976., 31912., 30208., 31192., 32176., 33160., 30484.,
      31480., 32476., 33472., 30760., 31768., 32776., 33784., 31036., 32056.,
      33076., 34096., 31312., 32344., 33376., 34408., 32416., 33496., 34576.,
      35656., 32692., 33784., 34876., 35968., 32968., 34072., 35176., 36280.,
      33244., 34360., 35476., 36592., 33520., 34648., 35776., 36904., 34624.,
      35800., 36976., 38152., 34900., 36088., 37276., 38464., 35176., 36376.,
      37576., 38776., 35452., 36664., 37876., 39088., 35728., 36952., 38176.,
      39400.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      144711., 145440., 190314., 191268., 192222., 193176., 142038., 142740.,
      143442., 144144., 156375., 157104., 205578., 206532., 207486., 208440.,
      153270., 153972., 154674., 155376., 199164., 200064., 261656., 262832.,
      264008., 265184., 194880., 195744., 196608., 197472., 138339., 138960.,
      181530., 182340., 183150., 183960., 135018., 135612., 136206., 136800.,
      148275., 148896., 194490., 195300., 196110., 196920., 144522., 145116.,
      145710., 146304.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14006., 14084., 14162., 14240., 14318., 14396., 14474., 14552., 14630.,
      14708., 15254., 15332., 15410., 15488., 15566., 15644., 15722., 15800.,
      15878., 15956., 16502., 16580., 16658., 16736., 16814., 16892., 16970.,
      17048., 17126., 17204., 17750., 17828., 17906., 17984., 18062., 18140.,
      18218., 18296., 18374., 18452., 18998., 19076., 19154., 19232., 19310.,
      19388., 19466., 19544., 19622., 19700.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      285345., 289422., 286776., 290880., 375192., 380628., 377064., 382536.,
      378936., 384444., 380808., 386352., 279945., 284076., 281322., 285480.,
      282699., 286884., 284076., 288288., 308241., 312750., 309672., 314208.,
      405144., 411156., 407016., 413064., 408888., 414972., 410760., 416880.,
      301977., 306540., 303354., 307944., 304731., 309348., 306108., 310752.,
      392316., 398328., 394080., 400128., 515296., 523312., 517600., 525664.,
      519904., 528016., 522208., 530368., 383676., 389760., 385368., 391488.,
      387060., 393216., 388752., 394944., 272169., 276678., 273384., 277920.,
      357048., 363060., 358632., 364680., 360216., 366300., 361800., 367920.,
      265473., 270036., 266634., 271224., 267795., 272412., 268956., 273600.,
      291609., 296550., 292824., 297792., 382392., 388980., 383976., 390600.,
      385560., 392220., 387144., 393840., 284049., 289044., 285210., 290232.,
      286371., 291420., 287532., 292608.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26440., 28012., 26584., 28168., 26728., 28324., 26872., 28480., 27016.,
      28636., 27160., 28792., 27304., 28948., 27448., 29104., 27592., 29260.,
      27736., 29416., 28744., 30508., 28888., 30664., 29032., 30820., 29176.,
      30976., 29320., 31132., 29464., 31288., 29608., 31444., 29752., 31600.,
      29896., 31756., 30040., 31912., 31048., 33004., 31192., 33160., 31336.,
      33316., 31480., 33472., 31624., 33628., 31768., 33784., 31912., 33940.,
      32056., 34096., 32200., 34252., 32344., 34408., 33352., 35500., 33496.,
      35656., 33640., 35812., 33784., 35968., 33928., 36124., 34072., 36280.,
      34216., 36436., 34360., 36592., 34504., 36748., 34648., 36904., 35656.,
      37996., 35800., 38152., 35944., 38308., 36088., 38464., 36232., 38620.,
      36376., 38776., 36520., 38932., 36664., 39088., 36808., 39244., 36952.,
      39400.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      566613.,  570690.,  574767.,  578844.,  569448.,  573552.,  577656.,
      581760.,  744948.,  750384.,  755820.,  761256.,  748656.,  754128.,
      759600.,  765072.,  752364.,  757872.,  763380.,  768888.,  756072.,
      761616.,  767160.,  772704.,  555759.,  559890.,  564021.,  568152.,
      558486.,  562644.,  566802.,  570960.,  561213.,  565398.,  569583.,
      573768.,  563940.,  568152.,  572364.,  576576.,  611973.,  616482.,
      620991.,  625500.,  614808.,  619344.,  623880.,  628416.,  804276.,
      810288.,  816300.,  822312.,  807984.,  814032.,  820080.,  826128.,
      811692.,  817776.,  823860.,  829944.,  815400.,  821520.,  827640.,
      833760.,  599391.,  603954.,  608517.,  613080.,  602118.,  606708.,
      611298.,  615888.,  604845.,  609462.,  614079.,  618696.,  607572.,
      612216.,  616860.,  621504.,  778620.,  784632.,  790644.,  796656.,
      782112.,  788160.,  794208.,  800256.,  1022576., 1030592., 1038608.,
      1046624., 1027136., 1035200., 1043264., 1051328., 1031696., 1039808.,
      1047920., 1056032., 1036256., 1044416., 1052576., 1060736., 761268.,
      767352.,  773436.,  779520.,  764616.,  770736.,  776856.,  782976.,
      767964.,  774120.,  780276.,  786432.,  771312.,  777504.,  783696.,
      789888.,  539829.,  544338.,  548847.,  553356.,  542232.,  546768.,
      551304.,  555840.,  708084.,  714096.,  720108.,  726120.,  711216.,
      717264.,  723312.,  729360.,  714348.,  720432.,  726516.,  732600.,
      717480.,  723600.,  729720.,  735840.,  526383.,  530946.,  535509.,
      540072.,  528678.,  533268.,  537858.,  542448.,  530973.,  535590.,
      540207.,  544824.,  533268.,  537912.,  542556.,  547200.,  578277.,
      583218.,  588159.,  593100.,  580680.,  585648.,  590616.,  595584.,
      758196.,  764784.,  771372.,  777960.,  761328.,  767952.,  774576.,
      781200.,  764460.,  771120.,  777780.,  784440.,  767592.,  774288.,
      780984.,  787680.,  563103.,  568098.,  573093.,  578088.,  565398.,
      570420.,  575442.,  580464.,  567693.,  572742.,  577791.,  582840.,
      569988.,  575064.,  580140.,  585216.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      51308., 52880., 54452., 56024., 51584., 53168., 54752., 56336., 51860.,
      53456., 55052., 56648., 52136., 53744., 55352., 56960., 52412., 54032.,
      55652., 57272., 52688., 54320., 55952., 57584., 52964., 54608., 56252.,
      57896., 53240., 54896., 56552., 58208., 53516., 55184., 56852., 58520.,
      53792., 55472., 57152., 58832., 55724., 57488., 59252., 61016., 56000.,
      57776., 59552., 61328., 56276., 58064., 59852., 61640., 56552., 58352.,
      60152., 61952., 56828., 58640., 60452., 62264., 57104., 58928., 60752.,
      62576., 57380., 59216., 61052., 62888., 57656., 59504., 61352., 63200.,
      57932., 59792., 61652., 63512., 58208., 60080., 61952., 63824., 60140.,
      62096., 64052., 66008., 60416., 62384., 64352., 66320., 60692., 62672.,
      64652., 66632., 60968., 62960., 64952., 66944., 61244., 63248., 65252.,
      67256., 61520., 63536., 65552., 67568., 61796., 63824., 65852., 67880.,
      62072., 64112., 66152., 68192., 62348., 64400., 66452., 68504., 62624.,
      64688., 66752., 68816., 64556., 66704., 68852., 71000., 64832., 66992.,
      69152., 71312., 65108., 67280., 69452., 71624., 65384., 67568., 69752.,
      71936., 65660., 67856., 70052., 72248., 65936., 68144., 70352., 72560.,
      66212., 68432., 70652., 72872., 66488., 68720., 70952., 73184., 66764.,
      69008., 71252., 73496., 67040., 69296., 71552., 73808., 68972., 71312.,
      73652., 75992., 69248., 71600., 73952., 76304., 69524., 71888., 74252.,
      76616., 69800., 72176., 74552., 76928., 70076., 72464., 74852., 77240.,
      70352., 72752., 75152., 77552., 70628., 73040., 75452., 77864., 70904.,
      73328., 75752., 78176., 71180., 73616., 76052., 78488., 71456., 73904.,
      76352., 78800.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      288693., 289422., 290151., 290880., 379674., 380628., 381582., 382536.,
      383490., 384444., 385398., 386352., 283374., 284076., 284778., 285480.,
      286182., 286884., 287586., 288288., 312021., 312750., 313479., 314208.,
      410202., 411156., 412110., 413064., 414018., 414972., 415926., 416880.,
      305838., 306540., 307242., 307944., 308646., 309348., 310050., 310752.,
      397428., 398328., 399228., 400128., 522136., 523312., 524488., 525664.,
      526840., 528016., 529192., 530368., 388896., 389760., 390624., 391488.,
      392352., 393216., 394080., 394944., 276057., 276678., 277299., 277920.,
      362250., 363060., 363870., 364680., 365490., 366300., 367110., 367920.,
      269442., 270036., 270630., 271224., 271818., 272412., 273006., 273600.,
      295929., 296550., 297171., 297792., 388170., 388980., 389790., 390600.,
      391410., 392220., 393030., 393840., 288450., 289044., 289638., 290232.,
      290826., 291420., 292014., 292608.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27934., 28012., 28090., 28168., 28246., 28324., 28402., 28480., 28558.,
      28636., 28714., 28792., 28870., 28948., 29026., 29104., 29182., 29260.,
      29338., 29416., 30430., 30508., 30586., 30664., 30742., 30820., 30898.,
      30976., 31054., 31132., 31210., 31288., 31366., 31444., 31522., 31600.,
      31678., 31756., 31834., 31912., 32926., 33004., 33082., 33160., 33238.,
      33316., 33394., 33472., 33550., 33628., 33706., 33784., 33862., 33940.,
      34018., 34096., 34174., 34252., 34330., 34408., 35422., 35500., 35578.,
      35656., 35734., 35812., 35890., 35968., 36046., 36124., 36202., 36280.,
      36358., 36436., 36514., 36592., 36670., 36748., 36826., 36904., 37918.,
      37996., 38074., 38152., 38230., 38308., 38386., 38464., 38542., 38620.,
      38698., 38776., 38854., 38932., 39010., 39088., 39166., 39244., 39322.,
      39400.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      569259.,  577386.,  570690.,  578844.,  572121.,  580302.,  573552.,
      581760.,  748512.,  759348.,  750384.,  761256.,  752256.,  763164.,
      754128.,  765072.,  756000.,  766980.,  757872.,  768888.,  759744.,
      770796.,  761616.,  772704.,  558513.,  566748.,  559890.,  568152.,
      561267.,  569556.,  562644.,  570960.,  564021.,  572364.,  565398.,
      573768.,  566775.,  575172.,  568152.,  576576.,  615051.,  624042.,
      616482.,  625500.,  617913.,  626958.,  619344.,  628416.,  808416.,
      820404.,  810288.,  822312.,  812160.,  824220.,  814032.,  826128.,
      815904.,  828036.,  817776.,  829944.,  819648.,  831852.,  821520.,
      833760.,  602577.,  611676.,  603954.,  613080.,  605331.,  614484.,
      606708.,  615888.,  608085.,  617292.,  609462.,  618696.,  610839.,
      620100.,  612216.,  621504.,  782868.,  794856.,  784632.,  796656.,
      786396.,  798456.,  788160.,  800256.,  1028288., 1044272., 1030592.,
      1046624., 1032896., 1048976., 1035200., 1051328., 1037504., 1053680.,
      1039808., 1056032., 1042112., 1058384., 1044416., 1060736., 765660.,
      777792.,  767352.,  779520.,  769044.,  781248.,  770736.,  782976.,
      772428.,  784704.,  774120.,  786432.,  775812.,  788160.,  777504.,
      789888.,  543123.,  552114.,  544338.,  553356.,  545553.,  554598.,
      546768.,  555840.,  712512.,  724500.,  714096.,  726120.,  715680.,
      727740.,  717264.,  729360.,  718848.,  730980.,  720432.,  732600.,
      722016.,  734220.,  723600.,  735840.,  529785.,  538884.,  530946.,
      540072.,  532107.,  541260.,  533268.,  542448.,  534429.,  543636.,
      535590.,  544824.,  536751.,  546012.,  537912.,  547200.,  582003.,
      591858.,  583218.,  593100.,  584433.,  594342.,  585648.,  595584.,
      763200.,  776340.,  764784.,  777960.,  766368.,  779580.,  767952.,
      781200.,  769536.,  782820.,  771120.,  784440.,  772704.,  786060.,
      774288.,  787680.,  566937.,  576900.,  568098.,  578088.,  569259.,
      579276.,  570420.,  580464.,  571581.,  581652.,  572742.,  582840.,
      573903.,  584028.,  575064.,  585216.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52736., 55868., 52880., 56024., 53024., 56180., 53168., 56336., 53312.,
      56492., 53456., 56648., 53600., 56804., 53744., 56960., 53888., 57116.,
      54032., 57272., 54176., 57428., 54320., 57584., 54464., 57740., 54608.,
      57896., 54752., 58052., 54896., 58208., 55040., 58364., 55184., 58520.,
      55328., 58676., 55472., 58832., 57344., 60860., 57488., 61016., 57632.,
      61172., 57776., 61328., 57920., 61484., 58064., 61640., 58208., 61796.,
      58352., 61952., 58496., 62108., 58640., 62264., 58784., 62420., 58928.,
      62576., 59072., 62732., 59216., 62888., 59360., 63044., 59504., 63200.,
      59648., 63356., 59792., 63512., 59936., 63668., 60080., 63824., 61952.,
      65852., 62096., 66008., 62240., 66164., 62384., 66320., 62528., 66476.,
      62672., 66632., 62816., 66788., 62960., 66944., 63104., 67100., 63248.,
      67256., 63392., 67412., 63536., 67568., 63680., 67724., 63824., 67880.,
      63968., 68036., 64112., 68192., 64256., 68348., 64400., 68504., 64544.,
      68660., 64688., 68816., 66560., 70844., 66704., 71000., 66848., 71156.,
      66992., 71312., 67136., 71468., 67280., 71624., 67424., 71780., 67568.,
      71936., 67712., 72092., 67856., 72248., 68000., 72404., 68144., 72560.,
      68288., 72716., 68432., 72872., 68576., 73028., 68720., 73184., 68864.,
      73340., 69008., 73496., 69152., 73652., 69296., 73808., 71168., 75836.,
      71312., 75992., 71456., 76148., 71600., 76304., 71744., 76460., 71888.,
      76616., 72032., 76772., 72176., 76928., 72320., 77084., 72464., 77240.,
      72608., 77396., 72752., 77552., 72896., 77708., 73040., 77864., 73184.,
      78020., 73328., 78176., 73472., 78332., 73616., 78488., 73760., 78644.,
      73904., 78800.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1130391., 1138518., 1146645., 1154772., 1133226., 1141380., 1149534.,
      1157688., 1136061., 1144242., 1152423., 1160604., 1138896., 1147104.,
      1155312., 1163520., 1486188., 1497024., 1507860., 1518696., 1489896.,
      1500768., 1511640., 1522512., 1493604., 1504512., 1515420., 1526328.,
      1497312., 1508256., 1519200., 1530144., 1501020., 1512000., 1522980.,
      1533960., 1504728., 1515744., 1526760., 1537776., 1508436., 1519488.,
      1530540., 1541592., 1512144., 1523232., 1534320., 1545408., 1108791.,
      1117026., 1125261., 1133496., 1111518., 1119780., 1128042., 1136304.,
      1114245., 1122534., 1130823., 1139112., 1116972., 1125288., 1133604.,
      1141920., 1119699., 1128042., 1136385., 1144728., 1122426., 1130796.,
      1139166., 1147536., 1125153., 1133550., 1141947., 1150344., 1127880.,
      1136304., 1144728., 1153152., 1221111., 1230102., 1239093., 1248084.,
      1223946., 1232964., 1241982., 1251000., 1226781., 1235826., 1244871.,
      1253916., 1229616., 1238688., 1247760., 1256832., 1604844., 1616832.,
      1628820., 1640808., 1608552., 1620576., 1632600., 1644624., 1612260.,
      1624320., 1636380., 1648440., 1615968., 1628064., 1640160., 1652256.,
      1619676., 1631808., 1643940., 1656072., 1623384., 1635552., 1647720.,
      1659888., 1627092., 1639296., 1651500., 1663704., 1630800., 1643040.,
      1655280., 1667520., 1196055., 1205154., 1214253., 1223352., 1198782.,
      1207908., 1217034., 1226160., 1201509., 1210662., 1219815., 1228968.,
      1204236., 1213416., 1222596., 1231776., 1206963., 1216170., 1225377.,
      1234584., 1209690., 1218924., 1228158., 1237392., 1212417., 1221678.,
      1230939., 1240200., 1215144., 1224432., 1233720., 1243008., 1553748.,
      1565736., 1577724., 1589712., 1557240., 1569264., 1581288., 1593312.,
      1560732., 1572792., 1584852., 1596912., 1564224., 1576320., 1588416.,
      1600512., 2040592., 2056576., 2072560., 2088544., 2045152., 2061184.,
      2077216., 2093248., 2049712., 2065792., 2081872., 2097952., 2054272.,
      2070400., 2086528., 2102656., 2058832., 2075008., 2091184., 2107360.,
      2063392., 2079616., 2095840., 2112064., 2067952., 2084224., 2100496.,
      2116768., 2072512., 2088832., 2105152., 2121472., 1519188., 1531320.,
      1543452., 1555584., 1522536., 1534704., 1546872., 1559040., 1525884.,
      1538088., 1550292., 1562496., 1529232., 1541472., 1553712., 1565952.,
      1532580., 1544856., 1557132., 1569408., 1535928., 1548240., 1560552.,
      1572864., 1539276., 1551624., 1563972., 1576320., 1542624., 1555008.,
      1567392., 1579776., 1077255., 1086246., 1095237., 1104228., 1079658.,
      1088676., 1097694., 1106712., 1082061., 1091106., 1100151., 1109196.,
      1084464., 1093536., 1102608., 1111680., 1413036., 1425024., 1437012.,
      1449000., 1416168., 1428192., 1440216., 1452240., 1419300., 1431360.,
      1443420., 1455480., 1422432., 1434528., 1446624., 1458720., 1425564.,
      1437696., 1449828., 1461960., 1428696., 1440864., 1453032., 1465200.,
      1431828., 1444032., 1456236., 1468440., 1434960., 1447200., 1459440.,
      1471680., 1050471., 1059570., 1068669., 1077768., 1052766., 1061892.,
      1071018., 1080144., 1055061., 1064214., 1073367., 1082520., 1057356.,
      1066536., 1075716., 1084896., 1059651., 1068858., 1078065., 1087272.,
      1061946., 1071180., 1080414., 1089648., 1064241., 1073502., 1082763.,
      1092024., 1066536., 1075824., 1085112., 1094400., 1154151., 1164006.,
      1173861., 1183716., 1156554., 1166436., 1176318., 1186200., 1158957.,
      1168866., 1178775., 1188684., 1161360., 1171296., 1181232., 1191168.,
      1513260., 1526400., 1539540., 1552680., 1516392., 1529568., 1542744.,
      1555920., 1519524., 1532736., 1545948., 1559160., 1522656., 1535904.,
      1549152., 1562400., 1525788., 1539072., 1552356., 1565640., 1528920.,
      1542240., 1555560., 1568880., 1532052., 1545408., 1558764., 1572120.,
      1535184., 1548576., 1561968., 1575360., 1123911., 1133874., 1143837.,
      1153800., 1126206., 1136196., 1146186., 1156176., 1128501., 1138518.,
      1148535., 1158552., 1130796., 1140840., 1150884., 1160928., 1133091.,
      1143162., 1153233., 1163304., 1135386., 1145484., 1155582., 1165680.,
      1137681., 1147806., 1157931., 1168056., 1139976., 1150128., 1160280.,
      1170432.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      102340., 105472., 108604., 111736., 102616., 105760., 108904., 112048.,
      102892., 106048., 109204., 112360., 103168., 106336., 109504., 112672.,
      103444., 106624., 109804., 112984., 103720., 106912., 110104., 113296.,
      103996., 107200., 110404., 113608., 104272., 107488., 110704., 113920.,
      104548., 107776., 111004., 114232., 104824., 108064., 111304., 114544.,
      105100., 108352., 111604., 114856., 105376., 108640., 111904., 115168.,
      105652., 108928., 112204., 115480., 105928., 109216., 112504., 115792.,
      106204., 109504., 112804., 116104., 106480., 109792., 113104., 116416.,
      106756., 110080., 113404., 116728., 107032., 110368., 113704., 117040.,
      107308., 110656., 114004., 117352., 107584., 110944., 114304., 117664.,
      111172., 114688., 118204., 121720., 111448., 114976., 118504., 122032.,
      111724., 115264., 118804., 122344., 112000., 115552., 119104., 122656.,
      112276., 115840., 119404., 122968., 112552., 116128., 119704., 123280.,
      112828., 116416., 120004., 123592., 113104., 116704., 120304., 123904.,
      113380., 116992., 120604., 124216., 113656., 117280., 120904., 124528.,
      113932., 117568., 121204., 124840., 114208., 117856., 121504., 125152.,
      114484., 118144., 121804., 125464., 114760., 118432., 122104., 125776.,
      115036., 118720., 122404., 126088., 115312., 119008., 122704., 126400.,
      115588., 119296., 123004., 126712., 115864., 119584., 123304., 127024.,
      116140., 119872., 123604., 127336., 116416., 120160., 123904., 127648.,
      120004., 123904., 127804., 131704., 120280., 124192., 128104., 132016.,
      120556., 124480., 128404., 132328., 120832., 124768., 128704., 132640.,
      121108., 125056., 129004., 132952., 121384., 125344., 129304., 133264.,
      121660., 125632., 129604., 133576., 121936., 125920., 129904., 133888.,
      122212., 126208., 130204., 134200., 122488., 126496., 130504., 134512.,
      122764., 126784., 130804., 134824., 123040., 127072., 131104., 135136.,
      123316., 127360., 131404., 135448., 123592., 127648., 131704., 135760.,
      123868., 127936., 132004., 136072., 124144., 128224., 132304., 136384.,
      124420., 128512., 132604., 136696., 124696., 128800., 132904., 137008.,
      124972., 129088., 133204., 137320., 125248., 129376., 133504., 137632.,
      128836., 133120., 137404., 141688., 129112., 133408., 137704., 142000.,
      129388., 133696., 138004., 142312., 129664., 133984., 138304., 142624.,
      129940., 134272., 138604., 142936., 130216., 134560., 138904., 143248.,
      130492., 134848., 139204., 143560., 130768., 135136., 139504., 143872.,
      131044., 135424., 139804., 144184., 131320., 135712., 140104., 144496.,
      131596., 136000., 140404., 144808., 131872., 136288., 140704., 145120.,
      132148., 136576., 141004., 145432., 132424., 136864., 141304., 145744.,
      132700., 137152., 141604., 146056., 132976., 137440., 141904., 146368.,
      133252., 137728., 142204., 146680., 133528., 138016., 142504., 146992.,
      133804., 138304., 142804., 147304., 134080., 138592., 143104., 147616.,
      137668., 142336., 147004., 151672., 137944., 142624., 147304., 151984.,
      138220., 142912., 147604., 152296., 138496., 143200., 147904., 152608.,
      138772., 143488., 148204., 152920., 139048., 143776., 148504., 153232.,
      139324., 144064., 148804., 153544., 139600., 144352., 149104., 153856.,
      139876., 144640., 149404., 154168., 140152., 144928., 149704., 154480.,
      140428., 145216., 150004., 154792., 140704., 145504., 150304., 155104.,
      140980., 145792., 150604., 155416., 141256., 146080., 150904., 155728.,
      141532., 146368., 151204., 156040., 141808., 146656., 151504., 156352.,
      142084., 146944., 151804., 156664., 142360., 147232., 152104., 156976.,
      142636., 147520., 152404., 157288., 142912., 147808., 152704., 157600.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      150660., 186255., 187740., 148410., 149580., 162720., 201105.,
      202590., 160110., 161280., 207160., 255890., 257720., 203560.,
      205000., 143820., 177480., 178740., 141030., 142020., 154080.,
      190080., 191340., 150930., 151920.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19527., 19698., 19869., 20040., 20211., 21237., 21408., 21579., 21750.,
      21921., 22947., 23118., 23289., 23460., 23631., 24657., 24828., 24999.,
      25170., 25341., 26367., 26538., 26709., 26880., 27051.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      297900., 301320., 368235., 372510., 371160., 375480., 293364., 296820.,
      295668., 299160., 321660., 325440., 397485., 402210., 400410., 405180.,
      316404., 320220., 318708., 322560., 409280., 414320., 505480., 511780.,
      509080., 515440., 402032., 407120., 404864., 410000., 283860., 287640.,
      350235., 354960., 352710., 357480., 278244., 282060., 280188., 284040.,
      304020., 308160., 374985., 380160., 377460., 382680., 297684., 301860.,
      299628., 303840.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37560., 39054., 37884., 39396., 38208., 39738., 38532., 40080., 38856.,
      40422., 40800., 42474., 41124., 42816., 41448., 43158., 41772., 43500.,
      42096., 43842., 44040., 45894., 44364., 46236., 44688., 46578., 45012.,
      46920., 45336., 47262., 47280., 49314., 47604., 49656., 47928., 49998.,
      48252., 50340., 48576., 50682., 50520., 52734., 50844., 53076., 51168.,
      53418., 51492., 53760., 51816., 54102.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      592380.,  595800.,  599220.,  602640.,  732195.,  736470.,  740745.,
      745020.,  738000.,  742320.,  746640.,  750960.,  583272.,  586728.,
      590184.,  593640.,  587844.,  591336.,  594828.,  598320.,  639540.,
      643320.,  647100.,  650880.,  790245.,  794970.,  799695.,  804420.,
      796050.,  800820.,  805590.,  810360.,  628992.,  632808.,  636624.,
      640440.,  633564.,  637416.,  641268.,  645120.,  813520.,  818560.,
      823600.,  828640.,  1004660., 1010960., 1017260., 1023560., 1011800.,
      1018160., 1024520., 1030880., 798976.,  804064.,  809152.,  814240.,
      804592.,  809728.,  814864.,  820000.,  563940.,  567720.,  571500.,
      575280.,  695745.,  700470.,  705195.,  709920.,  700650.,  705420.,
      710190.,  714960.,  552672.,  556488.,  560304.,  564120.,  556524.,
      560376.,  564228.,  568080.,  603900.,  608040.,  612180.,  616320.,
      744795.,  749970.,  755145.,  760320.,  749700.,  754920.,  760140.,
      765360.,  591192.,  595368.,  599544.,  603720.,  595044.,  599256.,
      603468.,  607680.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73626.,  75120.,  76614.,  78108.,  74256.,  75768.,  77280.,  78792.,
      74886.,  76416.,  77946.,  79476.,  75516.,  77064.,  78612.,  80160.,
      76146.,  77712.,  79278.,  80844.,  79926.,  81600.,  83274.,  84948.,
      80556.,  82248.,  83940.,  85632.,  81186.,  82896.,  84606.,  86316.,
      81816.,  83544.,  85272.,  87000.,  82446.,  84192.,  85938.,  87684.,
      86226.,  88080.,  89934.,  91788.,  86856.,  88728.,  90600.,  92472.,
      87486.,  89376.,  91266.,  93156.,  88116.,  90024.,  91932.,  93840.,
      88746.,  90672.,  92598.,  94524.,  92526.,  94560.,  96594.,  98628.,
      93156.,  95208.,  97260.,  99312.,  93786.,  95856.,  97926.,  99996.,
      94416.,  96504.,  98592.,  100680., 95046.,  97152.,  99258.,  101364.,
      98826.,  101040., 103254., 105468., 99456.,  101688., 103920., 106152.,
      100086., 102336., 104586., 106836., 100716., 102984., 105252., 107520.,
      101346., 103632., 105918., 108204.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      300114., 301320., 371025., 372510., 373995., 375480., 295650., 296820.,
      297990., 299160., 324234., 325440., 400725., 402210., 403695., 405180.,
      319050., 320220., 321390., 322560., 412832., 414320., 509950., 511780.,
      513610., 515440., 405680., 407120., 408560., 410000., 286614., 287640.,
      353700., 354960., 356220., 357480., 281070., 282060., 283050., 284040.,
      307134., 308160., 378900., 380160., 381420., 382680., 300870., 301860.,
      302850., 303840.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38883., 39054., 39225., 39396., 39567., 39738., 39909., 40080., 40251.,
      40422., 42303., 42474., 42645., 42816., 42987., 43158., 43329., 43500.,
      43671., 43842., 45723., 45894., 46065., 46236., 46407., 46578., 46749.,
      46920., 47091., 47262., 49143., 49314., 49485., 49656., 49827., 49998.,
      50169., 50340., 50511., 50682., 52563., 52734., 52905., 53076., 53247.,
      53418., 53589., 53760., 53931., 54102.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      593424.,  600228.,  595800.,  602640.,  733545.,  742050.,  736470.,
      745020.,  739395.,  747990.,  742320.,  750960.,  584424.,  591300.,
      586728.,  593640.,  589032.,  595980.,  591336.,  598320.,  640944.,
      648468.,  643320.,  650880.,  792045.,  801450.,  794970.,  804420.,
      797895.,  807390.,  800820.,  810360.,  630504.,  638100.,  632808.,
      640440.,  635112.,  642780.,  637416.,  645120.,  815632.,  825664.,
      818560.,  828640.,  1007360., 1019900., 1010960., 1023560., 1014560.,
      1027220., 1018160., 1030880., 801232.,  811360.,  804064.,  814240.,
      806896.,  817120.,  809728.,  820000.,  565704.,  573228.,  567720.,
      575280.,  697995.,  707400.,  700470.,  709920.,  702945.,  712440.,
      705420.,  714960.,  554544.,  562140.,  556488.,  564120.,  558432.,
      566100.,  560376.,  568080.,  606024.,  614268.,  608040.,  616320.,
      747495.,  757800.,  749970.,  760320.,  752445.,  762840.,  754920.,
      765360.,  593424.,  601740.,  595368.,  603720.,  597312.,  605700.,
      599256.,  607680.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      74796.,  77766.,  75120.,  78108.,  75444.,  78450.,  75768.,  78792.,
      76092.,  79134.,  76416.,  79476.,  76740.,  79818.,  77064.,  80160.,
      77388.,  80502.,  77712.,  80844.,  81276.,  84606.,  81600.,  84948.,
      81924.,  85290.,  82248.,  85632.,  82572.,  85974.,  82896.,  86316.,
      83220.,  86658.,  83544.,  87000.,  83868.,  87342.,  84192.,  87684.,
      87756.,  91446.,  88080.,  91788.,  88404.,  92130.,  88728.,  92472.,
      89052.,  92814.,  89376.,  93156.,  89700.,  93498.,  90024.,  93840.,
      90348.,  94182.,  90672.,  94524.,  94236.,  98286.,  94560.,  98628.,
      94884.,  98970.,  95208.,  99312.,  95532.,  99654.,  95856.,  99996.,
      96180.,  100338., 96504.,  100680., 96828.,  101022., 97152.,  101364.,
      100716., 105126., 101040., 105468., 101364., 105810., 101688., 106152.,
      102012., 106494., 102336., 106836., 102660., 107178., 102984., 107520.,
      103308., 107862., 103632., 108204.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1180044., 1186848., 1193652., 1200456., 1184760., 1191600., 1198440.,
      1205280., 1458585., 1467090., 1475595., 1484100., 1464390., 1472940.,
      1481490., 1490040., 1470195., 1478790., 1487385., 1495980., 1476000.,
      1484640., 1493280., 1501920., 1161972., 1168848., 1175724., 1182600.,
      1166544., 1173456., 1180368., 1187280., 1171116., 1178064., 1185012.,
      1191960., 1175688., 1182672., 1189656., 1196640., 1274364., 1281888.,
      1289412., 1296936., 1279080., 1286640., 1294200., 1301760., 1574685.,
      1584090., 1593495., 1602900., 1580490., 1589940., 1599390., 1608840.,
      1586295., 1595790., 1605285., 1614780., 1592100., 1601640., 1611180.,
      1620720., 1253412., 1261008., 1268604., 1276200., 1257984., 1265616.,
      1273248., 1280880., 1262556., 1270224., 1277892., 1285560., 1267128.,
      1274832., 1282536., 1290240., 1621232., 1631264., 1641296., 1651328.,
      1627040., 1637120., 1647200., 1657280., 2002180., 2014720., 2027260.,
      2039800., 2009320., 2021920., 2034520., 2047120., 2016460., 2029120.,
      2041780., 2054440., 2023600., 2036320., 2049040., 2061760., 1592336.,
      1602464., 1612592., 1622720., 1597952., 1608128., 1618304., 1628480.,
      1603568., 1613792., 1624016., 1634240., 1609184., 1619456., 1629728.,
      1640000., 1123884., 1131408., 1138932., 1146456., 1127880., 1135440.,
      1143000., 1150560., 1386585., 1395990., 1405395., 1414800., 1391490.,
      1400940., 1410390., 1419840., 1396395., 1405890., 1415385., 1424880.,
      1401300., 1410840., 1420380., 1429920., 1101492., 1109088., 1116684.,
      1124280., 1105344., 1112976., 1120608., 1128240., 1109196., 1116864.,
      1124532., 1132200., 1113048., 1120752., 1128456., 1136160., 1203804.,
      1212048., 1220292., 1228536., 1207800., 1216080., 1224360., 1232640.,
      1484685., 1494990., 1505295., 1515600., 1489590., 1499940., 1510290.,
      1520640., 1494495., 1504890., 1515285., 1525680., 1499400., 1509840.,
      1520280., 1530720., 1178532., 1186848., 1195164., 1203480., 1182384.,
      1190736., 1199088., 1207440., 1186236., 1194624., 1203012., 1211400.,
      1190088., 1198512., 1206936., 1215360.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      146622., 149592., 152562., 155532., 147252., 150240., 153228., 156216.,
      147882., 150888., 153894., 156900., 148512., 151536., 154560., 157584.,
      149142., 152184., 155226., 158268., 149772., 152832., 155892., 158952.,
      150402., 153480., 156558., 159636., 151032., 154128., 157224., 160320.,
      151662., 154776., 157890., 161004., 152292., 155424., 158556., 161688.,
      159222., 162552., 165882., 169212., 159852., 163200., 166548., 169896.,
      160482., 163848., 167214., 170580., 161112., 164496., 167880., 171264.,
      161742., 165144., 168546., 171948., 162372., 165792., 169212., 172632.,
      163002., 166440., 169878., 173316., 163632., 167088., 170544., 174000.,
      164262., 167736., 171210., 174684., 164892., 168384., 171876., 175368.,
      171822., 175512., 179202., 182892., 172452., 176160., 179868., 183576.,
      173082., 176808., 180534., 184260., 173712., 177456., 181200., 184944.,
      174342., 178104., 181866., 185628., 174972., 178752., 182532., 186312.,
      175602., 179400., 183198., 186996., 176232., 180048., 183864., 187680.,
      176862., 180696., 184530., 188364., 177492., 181344., 185196., 189048.,
      184422., 188472., 192522., 196572., 185052., 189120., 193188., 197256.,
      185682., 189768., 193854., 197940., 186312., 190416., 194520., 198624.,
      186942., 191064., 195186., 199308., 187572., 191712., 195852., 199992.,
      188202., 192360., 196518., 200676., 188832., 193008., 197184., 201360.,
      189462., 193656., 197850., 202044., 190092., 194304., 198516., 202728.,
      197022., 201432., 205842., 210252., 197652., 202080., 206508., 210936.,
      198282., 202728., 207174., 211620., 198912., 203376., 207840., 212304.,
      199542., 204024., 208506., 212988., 200172., 204672., 209172., 213672.,
      200802., 205320., 209838., 214356., 201432., 205968., 210504., 215040.,
      202062., 206616., 211170., 215724., 202692., 207264., 211836., 216408.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      599022.,  600228.,  601434.,  602640.,  740565.,  742050.,  743535.,
      745020.,  746505.,  747990.,  749475.,  750960.,  590130.,  591300.,
      592470.,  593640.,  594810.,  595980.,  597150.,  598320.,  647262.,
      648468.,  649674.,  650880.,  799965.,  801450.,  802935.,  804420.,
      805905.,  807390.,  808875.,  810360.,  636930.,  638100.,  639270.,
      640440.,  641610.,  642780.,  643950.,  645120.,  824176.,  825664.,
      827152.,  828640.,  1018070., 1019900., 1021730., 1023560., 1025390.,
      1027220., 1029050., 1030880., 809920.,  811360.,  812800.,  814240.,
      815680.,  817120.,  818560.,  820000.,  572202.,  573228.,  574254.,
      575280.,  706140.,  707400.,  708660.,  709920.,  711180.,  712440.,
      713700.,  714960.,  561150.,  562140.,  563130.,  564120.,  565110.,
      566100.,  567090.,  568080.,  613242.,  614268.,  615294.,  616320.,
      756540.,  757800.,  759060.,  760320.,  761580.,  762840.,  764100.,
      765360.,  600750.,  601740.,  602730.,  603720.,  604710.,  605700.,
      606690.,  607680.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      77595.,  77766.,  77937.,  78108.,  78279.,  78450.,  78621.,  78792.,
      78963.,  79134.,  79305.,  79476.,  79647.,  79818.,  79989.,  80160.,
      80331.,  80502.,  80673.,  80844.,  84435.,  84606.,  84777.,  84948.,
      85119.,  85290.,  85461.,  85632.,  85803.,  85974.,  86145.,  86316.,
      86487.,  86658.,  86829.,  87000.,  87171.,  87342.,  87513.,  87684.,
      91275.,  91446.,  91617.,  91788.,  91959.,  92130.,  92301.,  92472.,
      92643.,  92814.,  92985.,  93156.,  93327.,  93498.,  93669.,  93840.,
      94011.,  94182.,  94353.,  94524.,  98115.,  98286.,  98457.,  98628.,
      98799.,  98970.,  99141.,  99312.,  99483.,  99654.,  99825.,  99996.,
      100167., 100338., 100509., 100680., 100851., 101022., 101193., 101364.,
      104955., 105126., 105297., 105468., 105639., 105810., 105981., 106152.,
      106323., 106494., 106665., 106836., 107007., 107178., 107349., 107520.,
      107691., 107862., 108033., 108204.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1184472., 1198044., 1186848., 1200456., 1189224., 1202868., 1191600.,
      1205280., 1464165., 1481130., 1467090., 1484100., 1470015., 1487070.,
      1472940., 1490040., 1475865., 1493010., 1478790., 1495980., 1481715.,
      1498950., 1484640., 1501920., 1166544., 1180260., 1168848., 1182600.,
      1171152., 1184940., 1173456., 1187280., 1175760., 1189620., 1178064.,
      1191960., 1180368., 1194300., 1182672., 1196640., 1279512., 1294524.,
      1281888., 1296936., 1284264., 1299348., 1286640., 1301760., 1581165.,
      1599930., 1584090., 1602900., 1587015., 1605870., 1589940., 1608840.,
      1592865., 1611810., 1595790., 1614780., 1598715., 1617750., 1601640.,
      1620720., 1258704., 1273860., 1261008., 1276200., 1263312., 1278540.,
      1265616., 1280880., 1267920., 1283220., 1270224., 1285560., 1272528.,
      1287900., 1274832., 1290240., 1628336., 1648352., 1631264., 1651328.,
      1634192., 1654304., 1637120., 1657280., 2011120., 2036140., 2014720.,
      2039800., 2018320., 2043460., 2021920., 2047120., 2025520., 2050780.,
      2029120., 2054440., 2032720., 2058100., 2036320., 2061760., 1599632.,
      1619840., 1602464., 1622720., 1605296., 1625600., 1608128., 1628480.,
      1610960., 1631360., 1613792., 1634240., 1616624., 1637120., 1619456.,
      1640000., 1129392., 1144404., 1131408., 1146456., 1133424., 1148508.,
      1135440., 1150560., 1393515., 1412280., 1395990., 1414800., 1398465.,
      1417320., 1400940., 1419840., 1403415., 1422360., 1405890., 1424880.,
      1408365., 1427400., 1410840., 1429920., 1107144., 1122300., 1109088.,
      1124280., 1111032., 1126260., 1112976., 1128240., 1114920., 1130220.,
      1116864., 1132200., 1118808., 1134180., 1120752., 1136160., 1210032.,
      1226484., 1212048., 1228536., 1214064., 1230588., 1216080., 1232640.,
      1492515., 1513080., 1494990., 1515600., 1497465., 1518120., 1499940.,
      1520640., 1502415., 1523160., 1504890., 1525680., 1507365., 1528200.,
      1509840., 1530720., 1184904., 1201500., 1186848., 1203480., 1188792.,
      1205460., 1190736., 1207440., 1192680., 1209420., 1194624., 1211400.,
      1196568., 1213380., 1198512., 1215360.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149268., 155190., 149592., 155532., 149916., 155874., 150240., 156216.,
      150564., 156558., 150888., 156900., 151212., 157242., 151536., 157584.,
      151860., 157926., 152184., 158268., 152508., 158610., 152832., 158952.,
      153156., 159294., 153480., 159636., 153804., 159978., 154128., 160320.,
      154452., 160662., 154776., 161004., 155100., 161346., 155424., 161688.,
      162228., 168870., 162552., 169212., 162876., 169554., 163200., 169896.,
      163524., 170238., 163848., 170580., 164172., 170922., 164496., 171264.,
      164820., 171606., 165144., 171948., 165468., 172290., 165792., 172632.,
      166116., 172974., 166440., 173316., 166764., 173658., 167088., 174000.,
      167412., 174342., 167736., 174684., 168060., 175026., 168384., 175368.,
      175188., 182550., 175512., 182892., 175836., 183234., 176160., 183576.,
      176484., 183918., 176808., 184260., 177132., 184602., 177456., 184944.,
      177780., 185286., 178104., 185628., 178428., 185970., 178752., 186312.,
      179076., 186654., 179400., 186996., 179724., 187338., 180048., 187680.,
      180372., 188022., 180696., 188364., 181020., 188706., 181344., 189048.,
      188148., 196230., 188472., 196572., 188796., 196914., 189120., 197256.,
      189444., 197598., 189768., 197940., 190092., 198282., 190416., 198624.,
      190740., 198966., 191064., 199308., 191388., 199650., 191712., 199992.,
      192036., 200334., 192360., 200676., 192684., 201018., 193008., 201360.,
      193332., 201702., 193656., 202044., 193980., 202386., 194304., 202728.,
      201108., 209910., 201432., 210252., 201756., 210594., 202080., 210936.,
      202404., 211278., 202728., 211620., 203052., 211962., 203376., 212304.,
      203700., 212646., 204024., 212988., 204348., 213330., 204672., 213672.,
      204996., 214014., 205320., 214356., 205644., 214698., 205968., 215040.,
      206292., 215382., 206616., 215724., 206940., 216066., 207264., 216408.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x7x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2355372., 2368944., 2382516., 2396088., 2360088., 2373696., 2387304.,
      2400912., 2364804., 2378448., 2392092., 2405736., 2369520., 2383200.,
      2396880., 2410560., 2911365., 2928330., 2945295., 2962260., 2917170.,
      2934180., 2951190., 2968200., 2922975., 2940030., 2957085., 2974140.,
      2928780., 2945880., 2962980., 2980080., 2934585., 2951730., 2968875.,
      2986020., 2940390., 2957580., 2974770., 2991960., 2946195., 2963430.,
      2980665., 2997900., 2952000., 2969280., 2986560., 3003840., 2319372.,
      2333088., 2346804., 2360520., 2323944., 2337696., 2351448., 2365200.,
      2328516., 2342304., 2356092., 2369880., 2333088., 2346912., 2360736.,
      2374560., 2337660., 2351520., 2365380., 2379240., 2342232., 2356128.,
      2370024., 2383920., 2346804., 2360736., 2374668., 2388600., 2351376.,
      2365344., 2379312., 2393280., 2544012., 2559024., 2574036., 2589048.,
      2548728., 2563776., 2578824., 2593872., 2553444., 2568528., 2583612.,
      2598696., 2558160., 2573280., 2588400., 2603520., 3143565., 3162330.,
      3181095., 3199860., 3149370., 3168180., 3186990., 3205800., 3155175.,
      3174030., 3192885., 3211740., 3160980., 3179880., 3198780., 3217680.,
      3166785., 3185730., 3204675., 3223620., 3172590., 3191580., 3210570.,
      3229560., 3178395., 3197430., 3216465., 3235500., 3184200., 3203280.,
      3222360., 3241440., 2502252., 2517408., 2532564., 2547720., 2506824.,
      2522016., 2537208., 2552400., 2511396., 2526624., 2541852., 2557080.,
      2515968., 2531232., 2546496., 2561760., 2520540., 2535840., 2551140.,
      2566440., 2525112., 2540448., 2555784., 2571120., 2529684., 2545056.,
      2560428., 2575800., 2534256., 2549664., 2565072., 2580480., 3236656.,
      3256672., 3276688., 3296704., 3242464., 3262528., 3282592., 3302656.,
      3248272., 3268384., 3288496., 3308608., 3254080., 3274240., 3294400.,
      3314560., 3997220., 4022240., 4047260., 4072280., 4004360., 4029440.,
      4054520., 4079600., 4011500., 4036640., 4061780., 4086920., 4018640.,
      4043840., 4069040., 4094240., 4025780., 4051040., 4076300., 4101560.,
      4032920., 4058240., 4083560., 4108880., 4040060., 4065440., 4090820.,
      4116200., 4047200., 4072640., 4098080., 4123520., 3179056., 3199264.,
      3219472., 3239680., 3184672., 3204928., 3225184., 3245440., 3190288.,
      3210592., 3230896., 3251200., 3195904., 3216256., 3236608., 3256960.,
      3201520., 3221920., 3242320., 3262720., 3207136., 3227584., 3248032.,
      3268480., 3212752., 3233248., 3253744., 3274240., 3218368., 3238912.,
      3259456., 3280000., 2243772., 2258784., 2273796., 2288808., 2247768.,
      2262816., 2277864., 2292912., 2251764., 2266848., 2281932., 2297016.,
      2255760., 2270880., 2286000., 2301120., 2768265., 2787030., 2805795.,
      2824560., 2773170., 2791980., 2810790., 2829600., 2778075., 2796930.,
      2815785., 2834640., 2782980., 2801880., 2820780., 2839680., 2787885.,
      2806830., 2825775., 2844720., 2792790., 2811780., 2830770., 2849760.,
      2797695., 2816730., 2835765., 2854800., 2802600., 2821680., 2840760.,
      2859840., 2199132., 2214288., 2229444., 2244600., 2202984., 2218176.,
      2233368., 2248560., 2206836., 2222064., 2237292., 2252520., 2210688.,
      2225952., 2241216., 2256480., 2214540., 2229840., 2245140., 2260440.,
      2218392., 2233728., 2249064., 2264400., 2222244., 2237616., 2252988.,
      2268360., 2226096., 2241504., 2256912., 2272320., 2403612., 2420064.,
      2436516., 2452968., 2407608., 2424096., 2440584., 2457072., 2411604.,
      2428128., 2444652., 2461176., 2415600., 2432160., 2448720., 2465280.,
      2964465., 2985030., 3005595., 3026160., 2969370., 2989980., 3010590.,
      3031200., 2974275., 2994930., 3015585., 3036240., 2979180., 2999880.,
      3020580., 3041280., 2984085., 3004830., 3025575., 3046320., 2988990.,
      3009780., 3030570., 3051360., 2993895., 3014730., 3035565., 3056400.,
      2998800., 3019680., 3040560., 3061440., 2353212., 2369808., 2386404.,
      2403000., 2357064., 2373696., 2390328., 2406960., 2360916., 2377584.,
      2394252., 2410920., 2364768., 2381472., 2398176., 2414880., 2368620.,
      2385360., 2402100., 2418840., 2372472., 2389248., 2406024., 2422800.,
      2376324., 2393136., 2409948., 2426760., 2380176., 2397024., 2413872.,
      2430720.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x7x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      292614., 298536., 304458., 310380., 293244., 299184., 305124., 311064.,
      293874., 299832., 305790., 311748., 294504., 300480., 306456., 312432.,
      295134., 301128., 307122., 313116., 295764., 301776., 307788., 313800.,
      296394., 302424., 308454., 314484., 297024., 303072., 309120., 315168.,
      297654., 303720., 309786., 315852., 298284., 304368., 310452., 316536.,
      298914., 305016., 311118., 317220., 299544., 305664., 311784., 317904.,
      300174., 306312., 312450., 318588., 300804., 306960., 313116., 319272.,
      301434., 307608., 313782., 319956., 302064., 308256., 314448., 320640.,
      302694., 308904., 315114., 321324., 303324., 309552., 315780., 322008.,
      303954., 310200., 316446., 322692., 304584., 310848., 317112., 323376.,
      317814., 324456., 331098., 337740., 318444., 325104., 331764., 338424.,
      319074., 325752., 332430., 339108., 319704., 326400., 333096., 339792.,
      320334., 327048., 333762., 340476., 320964., 327696., 334428., 341160.,
      321594., 328344., 335094., 341844., 322224., 328992., 335760., 342528.,
      322854., 329640., 336426., 343212., 323484., 330288., 337092., 343896.,
      324114., 330936., 337758., 344580., 324744., 331584., 338424., 345264.,
      325374., 332232., 339090., 345948., 326004., 332880., 339756., 346632.,
      326634., 333528., 340422., 347316., 327264., 334176., 341088., 348000.,
      327894., 334824., 341754., 348684., 328524., 335472., 342420., 349368.,
      329154., 336120., 343086., 350052., 329784., 336768., 343752., 350736.,
      343014., 350376., 357738., 365100., 343644., 351024., 358404., 365784.,
      344274., 351672., 359070., 366468., 344904., 352320., 359736., 367152.,
      345534., 352968., 360402., 367836., 346164., 353616., 361068., 368520.,
      346794., 354264., 361734., 369204., 347424., 354912., 362400., 369888.,
      348054., 355560., 363066., 370572., 348684., 356208., 363732., 371256.,
      349314., 356856., 364398., 371940., 349944., 357504., 365064., 372624.,
      350574., 358152., 365730., 373308., 351204., 358800., 366396., 373992.,
      351834., 359448., 367062., 374676., 352464., 360096., 367728., 375360.,
      353094., 360744., 368394., 376044., 353724., 361392., 369060., 376728.,
      354354., 362040., 369726., 377412., 354984., 362688., 370392., 378096.,
      368214., 376296., 384378., 392460., 368844., 376944., 385044., 393144.,
      369474., 377592., 385710., 393828., 370104., 378240., 386376., 394512.,
      370734., 378888., 387042., 395196., 371364., 379536., 387708., 395880.,
      371994., 380184., 388374., 396564., 372624., 380832., 389040., 397248.,
      373254., 381480., 389706., 397932., 373884., 382128., 390372., 398616.,
      374514., 382776., 391038., 399300., 375144., 383424., 391704., 399984.,
      375774., 384072., 392370., 400668., 376404., 384720., 393036., 401352.,
      377034., 385368., 393702., 402036., 377664., 386016., 394368., 402720.,
      378294., 386664., 395034., 403404., 378924., 387312., 395700., 404088.,
      379554., 387960., 396366., 404772., 380184., 388608., 397032., 405456.,
      393414., 402216., 411018., 419820., 394044., 402864., 411684., 420504.,
      394674., 403512., 412350., 421188., 395304., 404160., 413016., 421872.,
      395934., 404808., 413682., 422556., 396564., 405456., 414348., 423240.,
      397194., 406104., 415014., 423924., 397824., 406752., 415680., 424608.,
      398454., 407400., 416346., 425292., 399084., 408048., 417012., 425976.,
      399714., 408696., 417678., 426660., 400344., 409344., 418344., 427344.,
      400974., 409992., 419010., 428028., 401604., 410640., 419676., 428712.,
      402234., 411288., 420342., 429396., 402864., 411936., 421008., 430080.,
      403494., 412584., 421674., 430764., 404124., 413232., 422340., 431448.,
      404754., 413880., 423006., 432132., 405384., 414528., 423672., 432816.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      75492.,  76221., 100212., 74034.,  74736.,  96072.,  96972.,
      127408., 94056., 94920.,  102372., 103272., 135640., 100104.,
      100968., 71199., 71820.,  94218.,  69444.,  70038.,  75546.,
      76167.,  99888., 73602.,  74196.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6952., 7030., 7108., 7186., 7264., 7498., 7576., 7654., 7732.,
      7810., 8044., 8122., 8200., 8278., 8356., 8590., 8668., 8746.,
      8824., 8902., 9136., 9214., 9292., 9370., 9448.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      148824., 150984., 150255., 152442., 197508., 200424., 145881., 148068.,
      147258., 149472., 189264., 192144., 191028., 193944., 250928., 254816.,
      185196., 188112., 186888., 189840., 201612., 204744., 203376., 206544.,
      267056., 271280., 197040., 200208., 198732., 201936., 140049., 142398.,
      141264., 143640., 185268., 188436., 136512., 138888., 137673., 140076.,
      148554., 151092., 149769., 152334., 196356., 199776., 144639., 147204.,
      145800., 148392.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13124., 13904., 13268., 14060., 13412., 14216., 13556., 14372., 13700.,
      14528., 14132., 14996., 14276., 15152., 14420., 15308., 14564., 15464.,
      14708., 15620., 15140., 16088., 15284., 16244., 15428., 16400., 15572.,
      16556., 15716., 16712., 16148., 17180., 16292., 17336., 16436., 17492.,
      16580., 17648., 16724., 17804., 17156., 18272., 17300., 18428., 17444.,
      18584., 17588., 18740., 17732., 18896.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      295488., 297648., 299808., 301968., 298323., 300510., 302697., 304884.,
      392100., 395016., 397932., 400848., 289575., 291762., 293949., 296136.,
      292302., 294516., 296730., 298944., 375648., 378528., 381408., 384288.,
      379140., 382056., 384972., 387888., 497968., 501856., 505744., 509632.,
      367476., 370392., 373308., 376224., 370824., 373776., 376728., 379680.,
      400092., 403224., 406356., 409488., 403584., 406752., 409920., 413088.,
      529888., 534112., 538336., 542560., 390912., 394080., 397248., 400416.,
      394260., 397464., 400668., 403872., 277749., 280098., 282447., 284796.,
      280152., 282528., 284904., 287280., 367368., 370536., 373704., 376872.,
      270648., 273024., 275400., 277776., 272943., 275346., 277749., 280152.,
      294570., 297108., 299646., 302184., 296973., 299538., 302103., 304668.,
      389292., 392712., 396132., 399552., 286713., 289278., 291843., 294408.,
      289008., 291600., 294192., 296784.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25468., 26248., 27028., 27808., 25744., 26536., 27328., 28120., 26020.,
      26824., 27628., 28432., 26296., 27112., 27928., 28744., 26572., 27400.,
      28228., 29056., 27400., 28264., 29128., 29992., 27676., 28552., 29428.,
      30304., 27952., 28840., 29728., 30616., 28228., 29128., 30028., 30928.,
      28504., 29416., 30328., 31240., 29332., 30280., 31228., 32176., 29608.,
      30568., 31528., 32488., 29884., 30856., 31828., 32800., 30160., 31144.,
      32128., 33112., 30436., 31432., 32428., 33424., 31264., 32296., 33328.,
      34360., 31540., 32584., 33628., 34672., 31816., 32872., 33928., 34984.,
      32092., 33160., 34228., 35296., 32368., 33448., 34528., 35608., 33196.,
      34312., 35428., 36544., 33472., 34600., 35728., 36856., 33748., 34888.,
      36028., 37168., 34024., 35176., 36328., 37480., 34300., 35464., 36628.,
      37792.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      150255., 150984., 151713., 152442., 199470., 200424., 147366., 148068.,
      148770., 149472., 191244., 192144., 193044., 193944., 253640., 254816.,
      187248., 188112., 188976., 189840., 203844., 204744., 205644., 206544.,
      270104., 271280., 199344., 200208., 201072., 201936., 141777., 142398.,
      143019., 143640., 187626., 188436., 138294., 138888., 139482., 140076.,
      150471., 151092., 151713., 152334., 198966., 199776., 146610., 147204.,
      147798., 148392.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13826., 13904., 13982., 14060., 14138., 14216., 14294., 14372., 14450.,
      14528., 14918., 14996., 15074., 15152., 15230., 15308., 15386., 15464.,
      15542., 15620., 16010., 16088., 16166., 16244., 16322., 16400., 16478.,
      16556., 16634., 16712., 17102., 17180., 17258., 17336., 17414., 17492.,
      17570., 17648., 17726., 17804., 18194., 18272., 18350., 18428., 18506.,
      18584., 18662., 18740., 18818., 18896.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296217., 300510., 297648., 301968., 299079., 303426., 300510., 304884.,
      393144., 398940., 395016., 400848., 290385., 294732., 291762., 296136.,
      293139., 297540., 294516., 298944., 376764., 382488., 378528., 384288.,
      380292., 386088., 382056., 387888., 499552., 507280., 501856., 509632.,
      368700., 374496., 370392., 376224., 372084., 377952., 373776., 379680.,
      401460., 407688., 403224., 409488., 404988., 411288., 406752., 413088.,
      531808., 540208., 534112., 542560., 392388., 398688., 394080., 400416.,
      395772., 402144., 397464., 403872., 278883., 283554., 280098., 284796.,
      281313., 286038., 282528., 287280., 368952., 375252., 370536., 376872.,
      271863., 276588., 273024., 277776., 274185., 278964., 275346., 280152.,
      295893., 300942., 297108., 302184., 298323., 303426., 299538., 304668.,
      391128., 397932., 392712., 399552., 288117., 293220., 289278., 294408.,
      290439., 295596., 291600., 296784.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26104., 27652., 26248., 27808., 26392., 27964., 26536., 28120., 26680.,
      28276., 26824., 28432., 26968., 28588., 27112., 28744., 27256., 28900.,
      27400., 29056., 28120., 29836., 28264., 29992., 28408., 30148., 28552.,
      30304., 28696., 30460., 28840., 30616., 28984., 30772., 29128., 30928.,
      29272., 31084., 29416., 31240., 30136., 32020., 30280., 32176., 30424.,
      32332., 30568., 32488., 30712., 32644., 30856., 32800., 31000., 32956.,
      31144., 33112., 31288., 33268., 31432., 33424., 32152., 34204., 32296.,
      34360., 32440., 34516., 32584., 34672., 32728., 34828., 32872., 34984.,
      33016., 35140., 33160., 35296., 33304., 35452., 33448., 35608., 34168.,
      36388., 34312., 36544., 34456., 36700., 34600., 36856., 34744., 37012.,
      34888., 37168., 35032., 37324., 35176., 37480., 35320., 37636., 35464.,
      37792.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      588141.,  592434.,  596727.,  601020.,  590976.,  595296.,  599616.,
      603936.,  593811.,  598158.,  602505.,  606852.,  596646.,  601020.,
      605394.,  609768.,  780492.,  786288.,  792084.,  797880.,  784200.,
      790032.,  795864.,  801696.,  576423.,  580770.,  585117.,  589464.,
      579150.,  583524.,  587898.,  592272.,  581877.,  586278.,  590679.,
      595080.,  584604.,  589032.,  593460.,  597888.,  747804.,  753528.,
      759252.,  764976.,  751296.,  757056.,  762816.,  768576.,  754788.,
      760584.,  766380.,  772176.,  758280.,  764112.,  769944.,  775776.,
      991376.,  999104.,  1006832., 1014560., 995936.,  1003712., 1011488.,
      1019264., 731604.,  737400.,  743196.,  748992.,  734952.,  740784.,
      746616.,  752448.,  738300.,  744168.,  750036.,  755904.,  741648.,
      747552.,  753456.,  759360.,  796692.,  802920.,  809148.,  815376.,
      800184.,  806448.,  812712.,  818976.,  803676.,  809976.,  816276.,
      822576.,  807168.,  813504.,  819840.,  826176.,  1055216., 1063616.,
      1072016., 1080416., 1059776., 1068224., 1076672., 1085120., 778476.,
      784776.,  791076.,  797376.,  781824.,  788160.,  794496.,  800832.,
      785172.,  791544.,  797916.,  804288.,  788520.,  794928.,  801336.,
      807744.,  553095.,  557766.,  562437.,  567108.,  555498.,  560196.,
      564894.,  569592.,  557901.,  562626.,  567351.,  572076.,  560304.,
      565056.,  569808.,  574560.,  731604.,  737904.,  744204.,  750504.,
      734736.,  741072.,  747408.,  753744.,  539001.,  543726.,  548451.,
      553176.,  541296.,  546048.,  550800.,  555552.,  543591.,  548370.,
      553149.,  557928.,  545886.,  550692.,  555498.,  560304.,  586737.,
      591786.,  596835.,  601884.,  589140.,  594216.,  599292.,  604368.,
      591543.,  596646.,  601749.,  606852.,  593946.,  599076.,  604206.,
      609336.,  775452.,  782256.,  789060.,  795864.,  778584.,  785424.,
      792264.,  799104.,  571131.,  576234.,  581337.,  586440.,  573426.,
      578556.,  583686.,  588816.,  575721.,  580878.,  586035.,  591192.,
      578016.,  583200.,  588384.,  593568.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50660., 52208., 53756., 55304., 50936., 52496., 54056., 55616., 51212.,
      52784., 54356., 55928., 51488., 53072., 54656., 56240., 51764., 53360.,
      54956., 56552., 52040., 53648., 55256., 56864., 52316., 53936., 55556.,
      57176., 52592., 54224., 55856., 57488., 52868., 54512., 56156., 57800.,
      53144., 54800., 56456., 58112., 54524., 56240., 57956., 59672., 54800.,
      56528., 58256., 59984., 55076., 56816., 58556., 60296., 55352., 57104.,
      58856., 60608., 55628., 57392., 59156., 60920., 55904., 57680., 59456.,
      61232., 56180., 57968., 59756., 61544., 56456., 58256., 60056., 61856.,
      56732., 58544., 60356., 62168., 57008., 58832., 60656., 62480., 58388.,
      60272., 62156., 64040., 58664., 60560., 62456., 64352., 58940., 60848.,
      62756., 64664., 59216., 61136., 63056., 64976., 59492., 61424., 63356.,
      65288., 59768., 61712., 63656., 65600., 60044., 62000., 63956., 65912.,
      60320., 62288., 64256., 66224., 60596., 62576., 64556., 66536., 60872.,
      62864., 64856., 66848., 62252., 64304., 66356., 68408., 62528., 64592.,
      66656., 68720., 62804., 64880., 66956., 69032., 63080., 65168., 67256.,
      69344., 63356., 65456., 67556., 69656., 63632., 65744., 67856., 69968.,
      63908., 66032., 68156., 70280., 64184., 66320., 68456., 70592., 64460.,
      66608., 68756., 70904., 64736., 66896., 69056., 71216., 66116., 68336.,
      70556., 72776., 66392., 68624., 70856., 73088., 66668., 68912., 71156.,
      73400., 66944., 69200., 71456., 73712., 67220., 69488., 71756., 74024.,
      67496., 69776., 72056., 74336., 67772., 70064., 72356., 74648., 68048.,
      70352., 72656., 74960., 68324., 70640., 72956., 75272., 68600., 70928.,
      73256., 75584.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      299781., 300510., 301239., 301968., 302697., 303426., 304155., 304884.,
      397986., 398940., 399894., 400848., 294030., 294732., 295434., 296136.,
      296838., 297540., 298242., 298944., 381588., 382488., 383388., 384288.,
      385188., 386088., 386988., 387888., 506104., 507280., 508456., 509632.,
      373632., 374496., 375360., 376224., 377088., 377952., 378816., 379680.,
      406788., 407688., 408588., 409488., 410388., 411288., 412188., 413088.,
      539032., 540208., 541384., 542560., 397824., 398688., 399552., 400416.,
      401280., 402144., 403008., 403872., 282933., 283554., 284175., 284796.,
      285417., 286038., 286659., 287280., 374442., 375252., 376062., 376872.,
      275994., 276588., 277182., 277776., 278370., 278964., 279558., 280152.,
      300321., 300942., 301563., 302184., 302805., 303426., 304047., 304668.,
      397122., 397932., 398742., 399552., 292626., 293220., 293814., 294408.,
      295002., 295596., 296190., 296784.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      27574., 27652., 27730., 27808., 27886., 27964., 28042., 28120., 28198.,
      28276., 28354., 28432., 28510., 28588., 28666., 28744., 28822., 28900.,
      28978., 29056., 29758., 29836., 29914., 29992., 30070., 30148., 30226.,
      30304., 30382., 30460., 30538., 30616., 30694., 30772., 30850., 30928.,
      31006., 31084., 31162., 31240., 31942., 32020., 32098., 32176., 32254.,
      32332., 32410., 32488., 32566., 32644., 32722., 32800., 32878., 32956.,
      33034., 33112., 33190., 33268., 33346., 33424., 34126., 34204., 34282.,
      34360., 34438., 34516., 34594., 34672., 34750., 34828., 34906., 34984.,
      35062., 35140., 35218., 35296., 35374., 35452., 35530., 35608., 36310.,
      36388., 36466., 36544., 36622., 36700., 36778., 36856., 36934., 37012.,
      37090., 37168., 37246., 37324., 37402., 37480., 37558., 37636., 37714.,
      37792.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      591003.,  599562.,  592434.,  601020.,  593865.,  602478.,  595296.,
      603936.,  596727.,  605394.,  598158.,  606852.,  599589.,  608310.,
      601020.,  609768.,  784416.,  795972.,  786288.,  797880.,  788160.,
      799788.,  790032.,  801696.,  579393.,  588060.,  580770.,  589464.,
      582147.,  590868.,  583524.,  592272.,  584901.,  593676.,  586278.,
      595080.,  587655.,  596484.,  589032.,  597888.,  751764.,  763176.,
      753528.,  764976.,  755292.,  766776.,  757056.,  768576.,  758820.,
      770376.,  760584.,  772176.,  762348.,  773976.,  764112.,  775776.,
      996800.,  1012208., 999104.,  1014560., 1001408., 1016912., 1003712.,
      1019264., 735708.,  747264.,  737400.,  748992.,  739092.,  750720.,
      740784.,  752448.,  742476.,  754176.,  744168.,  755904.,  745860.,
      757632.,  747552.,  759360.,  801156.,  813576.,  802920.,  815376.,
      804684.,  817176.,  806448.,  818976.,  808212.,  820776.,  809976.,
      822576.,  811740.,  824376.,  813504.,  826176.,  1061312., 1078064.,
      1063616., 1080416., 1065920., 1082768., 1068224., 1085120., 783084.,
      795648.,  784776.,  797376.,  786468.,  799104.,  788160.,  800832.,
      789852.,  802560.,  791544.,  804288.,  793236.,  806016.,  794928.,
      807744.,  556551.,  565866.,  557766.,  567108.,  558981.,  568350.,
      560196.,  569592.,  561411.,  570834.,  562626.,  572076.,  563841.,
      573318.,  565056.,  574560.,  736320.,  748884.,  737904.,  750504.,
      739488.,  752124.,  741072.,  753744.,  542565.,  551988.,  543726.,
      553176.,  544887.,  554364.,  546048.,  555552.,  547209.,  556740.,
      548370.,  557928.,  549531.,  559116.,  550692.,  560304.,  590571.,
      600642.,  591786.,  601884.,  593001.,  603126.,  594216.,  604368.,
      595431.,  605610.,  596646.,  606852.,  597861.,  608094.,  599076.,
      609336.,  780672.,  794244.,  782256.,  795864.,  783840.,  797484.,
      785424.,  799104.,  575073.,  585252.,  576234.,  586440.,  577395.,
      587628.,  578556.,  588816.,  579717.,  590004.,  580878.,  591192.,
      582039.,  592380.,  583200.,  593568.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52064., 55148., 52208., 55304., 52352., 55460., 52496., 55616., 52640.,
      55772., 52784., 55928., 52928., 56084., 53072., 56240., 53216., 56396.,
      53360., 56552., 53504., 56708., 53648., 56864., 53792., 57020., 53936.,
      57176., 54080., 57332., 54224., 57488., 54368., 57644., 54512., 57800.,
      54656., 57956., 54800., 58112., 56096., 59516., 56240., 59672., 56384.,
      59828., 56528., 59984., 56672., 60140., 56816., 60296., 56960., 60452.,
      57104., 60608., 57248., 60764., 57392., 60920., 57536., 61076., 57680.,
      61232., 57824., 61388., 57968., 61544., 58112., 61700., 58256., 61856.,
      58400., 62012., 58544., 62168., 58688., 62324., 58832., 62480., 60128.,
      63884., 60272., 64040., 60416., 64196., 60560., 64352., 60704., 64508.,
      60848., 64664., 60992., 64820., 61136., 64976., 61280., 65132., 61424.,
      65288., 61568., 65444., 61712., 65600., 61856., 65756., 62000., 65912.,
      62144., 66068., 62288., 66224., 62432., 66380., 62576., 66536., 62720.,
      66692., 62864., 66848., 64160., 68252., 64304., 68408., 64448., 68564.,
      64592., 68720., 64736., 68876., 64880., 69032., 65024., 69188., 65168.,
      69344., 65312., 69500., 65456., 69656., 65600., 69812., 65744., 69968.,
      65888., 70124., 66032., 70280., 66176., 70436., 66320., 70592., 66464.,
      70748., 66608., 70904., 66752., 71060., 66896., 71216., 68192., 72620.,
      68336., 72776., 68480., 72932., 68624., 73088., 68768., 73244., 68912.,
      73400., 69056., 73556., 69200., 73712., 69344., 73868., 69488., 74024.,
      69632., 74180., 69776., 74336., 69920., 74492., 70064., 74648., 70208.,
      74804., 70352., 74960., 70496., 75116., 70640., 75272., 70784., 75428.,
      70928., 75584.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1173447., 1182006., 1190565., 1199124., 1176282., 1184868., 1193454.,
      1202040., 1179117., 1187730., 1196343., 1204956., 1181952., 1190592.,
      1199232., 1207872., 1184787., 1193454., 1202121., 1210788., 1187622.,
      1196316., 1205010., 1213704., 1190457., 1199178., 1207899., 1216620.,
      1193292., 1202040., 1210788., 1219536., 1557276., 1568832., 1580388.,
      1591944., 1560984., 1572576., 1584168., 1595760., 1564692., 1576320.,
      1587948., 1599576., 1568400., 1580064., 1591728., 1603392., 1150119.,
      1158786., 1167453., 1176120., 1152846., 1161540., 1170234., 1178928.,
      1155573., 1164294., 1173015., 1181736., 1158300., 1167048., 1175796.,
      1184544., 1161027., 1169802., 1178577., 1187352., 1163754., 1172556.,
      1181358., 1190160., 1166481., 1175310., 1184139., 1192968., 1169208.,
      1178064., 1186920., 1195776., 1492116., 1503528., 1514940., 1526352.,
      1495608., 1507056., 1518504., 1529952., 1499100., 1510584., 1522068.,
      1533552., 1502592., 1514112., 1525632., 1537152., 1506084., 1517640.,
      1529196., 1540752., 1509576., 1521168., 1532760., 1544352., 1513068.,
      1524696., 1536324., 1547952., 1516560., 1528224., 1539888., 1551552.,
      1978192., 1993600., 2009008., 2024416., 1982752., 1998208., 2013664.,
      2029120., 1987312., 2002816., 2018320., 2033824., 1991872., 2007424.,
      2022976., 2038528., 1459860., 1471416., 1482972., 1494528., 1463208.,
      1474800., 1486392., 1497984., 1466556., 1478184., 1489812., 1501440.,
      1469904., 1481568., 1493232., 1504896., 1473252., 1484952., 1496652.,
      1508352., 1476600., 1488336., 1500072., 1511808., 1479948., 1491720.,
      1503492., 1515264., 1483296., 1495104., 1506912., 1518720., 1589892.,
      1602312., 1614732., 1627152., 1593384., 1605840., 1618296., 1630752.,
      1596876., 1609368., 1621860., 1634352., 1600368., 1612896., 1625424.,
      1637952., 1603860., 1616424., 1628988., 1641552., 1607352., 1619952.,
      1632552., 1645152., 1610844., 1623480., 1636116., 1648752., 1614336.,
      1627008., 1639680., 1652352., 2105872., 2122624., 2139376., 2156128.,
      2110432., 2127232., 2144032., 2160832., 2114992., 2131840., 2148688.,
      2165536., 2119552., 2136448., 2153344., 2170240., 1553604., 1566168.,
      1578732., 1591296., 1556952., 1569552., 1582152., 1594752., 1560300.,
      1572936., 1585572., 1598208., 1563648., 1576320., 1588992., 1601664.,
      1566996., 1579704., 1592412., 1605120., 1570344., 1583088., 1595832.,
      1608576., 1573692., 1586472., 1599252., 1612032., 1577040., 1589856.,
      1602672., 1615488., 1103787., 1113102., 1122417., 1131732., 1106190.,
      1115532., 1124874., 1134216., 1108593., 1117962., 1127331., 1136700.,
      1110996., 1120392., 1129788., 1139184., 1113399., 1122822., 1132245.,
      1141668., 1115802., 1125252., 1134702., 1144152., 1118205., 1127682.,
      1137159., 1146636., 1120608., 1130112., 1139616., 1149120., 1460076.,
      1472640., 1485204., 1497768., 1463208., 1475808., 1488408., 1501008.,
      1466340., 1478976., 1491612., 1504248., 1469472., 1482144., 1494816.,
      1507488., 1075707., 1085130., 1094553., 1103976., 1078002., 1087452.,
      1096902., 1106352., 1080297., 1089774., 1099251., 1108728., 1082592.,
      1092096., 1101600., 1111104., 1084887., 1094418., 1103949., 1113480.,
      1087182., 1096740., 1106298., 1115856., 1089477., 1099062., 1108647.,
      1118232., 1091772., 1101384., 1110996., 1120608., 1171071., 1181142.,
      1191213., 1201284., 1173474., 1183572., 1193670., 1203768., 1175877.,
      1186002., 1196127., 1206252., 1178280., 1188432., 1198584., 1208736.,
      1180683., 1190862., 1201041., 1211220., 1183086., 1193292., 1203498.,
      1213704., 1185489., 1195722., 1205955., 1216188., 1187892., 1198152.,
      1208412., 1218672., 1547772., 1561344., 1574916., 1588488., 1550904.,
      1564512., 1578120., 1591728., 1554036., 1567680., 1581324., 1594968.,
      1557168., 1570848., 1584528., 1598208., 1139967., 1150146., 1160325.,
      1170504., 1142262., 1152468., 1162674., 1172880., 1144557., 1154790.,
      1165023., 1175256., 1146852., 1157112., 1167372., 1177632., 1149147.,
      1159434., 1169721., 1180008., 1151442., 1161756., 1172070., 1182384.,
      1153737., 1164078., 1174419., 1184760., 1156032., 1166400., 1176768.,
      1187136.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      101044., 104128., 107212., 110296., 101320., 104416., 107512., 110608.,
      101596., 104704., 107812., 110920., 101872., 104992., 108112., 111232.,
      102148., 105280., 108412., 111544., 102424., 105568., 108712., 111856.,
      102700., 105856., 109012., 112168., 102976., 106144., 109312., 112480.,
      103252., 106432., 109612., 112792., 103528., 106720., 109912., 113104.,
      103804., 107008., 110212., 113416., 104080., 107296., 110512., 113728.,
      104356., 107584., 110812., 114040., 104632., 107872., 111112., 114352.,
      104908., 108160., 111412., 114664., 105184., 108448., 111712., 114976.,
      105460., 108736., 112012., 115288., 105736., 109024., 112312., 115600.,
      106012., 109312., 112612., 115912., 106288., 109600., 112912., 116224.,
      108772., 112192., 115612., 119032., 109048., 112480., 115912., 119344.,
      109324., 112768., 116212., 119656., 109600., 113056., 116512., 119968.,
      109876., 113344., 116812., 120280., 110152., 113632., 117112., 120592.,
      110428., 113920., 117412., 120904., 110704., 114208., 117712., 121216.,
      110980., 114496., 118012., 121528., 111256., 114784., 118312., 121840.,
      111532., 115072., 118612., 122152., 111808., 115360., 118912., 122464.,
      112084., 115648., 119212., 122776., 112360., 115936., 119512., 123088.,
      112636., 116224., 119812., 123400., 112912., 116512., 120112., 123712.,
      113188., 116800., 120412., 124024., 113464., 117088., 120712., 124336.,
      113740., 117376., 121012., 124648., 114016., 117664., 121312., 124960.,
      116500., 120256., 124012., 127768., 116776., 120544., 124312., 128080.,
      117052., 120832., 124612., 128392., 117328., 121120., 124912., 128704.,
      117604., 121408., 125212., 129016., 117880., 121696., 125512., 129328.,
      118156., 121984., 125812., 129640., 118432., 122272., 126112., 129952.,
      118708., 122560., 126412., 130264., 118984., 122848., 126712., 130576.,
      119260., 123136., 127012., 130888., 119536., 123424., 127312., 131200.,
      119812., 123712., 127612., 131512., 120088., 124000., 127912., 131824.,
      120364., 124288., 128212., 132136., 120640., 124576., 128512., 132448.,
      120916., 124864., 128812., 132760., 121192., 125152., 129112., 133072.,
      121468., 125440., 129412., 133384., 121744., 125728., 129712., 133696.,
      124228., 128320., 132412., 136504., 124504., 128608., 132712., 136816.,
      124780., 128896., 133012., 137128., 125056., 129184., 133312., 137440.,
      125332., 129472., 133612., 137752., 125608., 129760., 133912., 138064.,
      125884., 130048., 134212., 138376., 126160., 130336., 134512., 138688.,
      126436., 130624., 134812., 139000., 126712., 130912., 135112., 139312.,
      126988., 131200., 135412., 139624., 127264., 131488., 135712., 139936.,
      127540., 131776., 136012., 140248., 127816., 132064., 136312., 140560.,
      128092., 132352., 136612., 140872., 128368., 132640., 136912., 141184.,
      128644., 132928., 137212., 141496., 128920., 133216., 137512., 141808.,
      129196., 133504., 137812., 142120., 129472., 133792., 138112., 142432.,
      131956., 136384., 140812., 145240., 132232., 136672., 141112., 145552.,
      132508., 136960., 141412., 145864., 132784., 137248., 141712., 146176.,
      133060., 137536., 142012., 146488., 133336., 137824., 142312., 146800.,
      133612., 138112., 142612., 147112., 133888., 138400., 142912., 147424.,
      134164., 138688., 143212., 147736., 134440., 138976., 143512., 148048.,
      134716., 139264., 143812., 148360., 134992., 139552., 144112., 148672.,
      135268., 139840., 144412., 148984., 135544., 140128., 144712., 149296.,
      135820., 140416., 145012., 149608., 136096., 140704., 145312., 149920.,
      136372., 140992., 145612., 150232., 136648., 141280., 145912., 150544.,
      136924., 141568., 146212., 150856., 137200., 141856., 146512., 151168.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86688.,  113970., 114924., 84906.,  85608.,  110304., 144920.,
      146096., 107856., 108720., 117504., 154328., 155504., 114768.,
      115632., 81720.,  107202., 108012., 79614.,  80208.,  86688.,
      113682., 114492., 84366.,  84960.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7922.,  8000.,  8078.,  8156.,  8234.,  8546.,  8624., 8702., 8780.,
      8858.,  9170.,  9248.,  9326.,  9404.,  9482.,  9794., 9872., 9950.,
      10028., 10106., 10418., 10496., 10574., 10652., 10730.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      170892., 173376., 224628., 227940., 226500., 229848., 167301., 169812.,
      168678., 171216., 217296., 220608., 285424., 289840., 287728., 292192.,
      212364., 215712., 214056., 217440., 231408., 235008., 303856., 308656.,
      306160., 311008., 225900., 229536., 227592., 231264., 160740., 163440.,
      210804., 214404., 212388., 216024., 156501., 159228., 157662., 160416.,
      170460., 173376., 223476., 227364., 225060., 228984., 165789., 168732.,
      166950., 169920.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14956., 15844., 15100., 16000., 15244., 16156., 15388., 16312., 15532.,
      16468., 16108., 17092., 16252., 17248., 16396., 17404., 16540., 17560.,
      16684., 17716., 17260., 18340., 17404., 18496., 17548., 18652., 17692.,
      18808., 17836., 18964., 18412., 19588., 18556., 19744., 18700., 19900.,
      18844., 20056., 18988., 20212., 19564., 20836., 19708., 20992., 19852.,
      21148., 19996., 21304., 20140., 21460.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      339300., 341784., 344268., 346752., 445944., 449256., 452568., 455880.,
      449652., 453000., 456348., 459696., 332091., 334602., 337113., 339624.,
      334818., 337356., 339894., 342432., 431280., 434592., 437904., 441216.,
      566432., 570848., 575264., 579680., 570992., 575456., 579920., 584384.,
      421380., 424728., 428076., 431424., 424728., 428112., 431496., 434880.,
      459216., 462816., 466416., 470016., 602912., 607712., 612512., 617312.,
      607472., 612320., 617168., 622016., 448164., 451800., 455436., 459072.,
      451512., 455184., 458856., 462528., 318780., 321480., 324180., 326880.,
      418008., 421608., 425208., 428808., 421140., 424776., 428412., 432048.,
      310275., 313002., 315729., 318456., 312570., 315324., 318078., 320832.,
      338004., 340920., 343836., 346752., 443064., 446952., 450840., 454728.,
      446196., 450120., 454044., 457968., 328635., 331578., 334521., 337464.,
      330930., 333900., 336870., 339840.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29024., 29912., 30800., 31688., 29300., 30200., 31100., 32000., 29576.,
      30488., 31400., 32312., 29852., 30776., 31700., 32624., 30128., 31064.,
      32000., 32936., 31232., 32216., 33200., 34184., 31508., 32504., 33500.,
      34496., 31784., 32792., 33800., 34808., 32060., 33080., 34100., 35120.,
      32336., 33368., 34400., 35432., 33440., 34520., 35600., 36680., 33716.,
      34808., 35900., 36992., 33992., 35096., 36200., 37304., 34268., 35384.,
      36500., 37616., 34544., 35672., 36800., 37928., 35648., 36824., 38000.,
      39176., 35924., 37112., 38300., 39488., 36200., 37400., 38600., 39800.,
      36476., 37688., 38900., 40112., 36752., 37976., 39200., 40424., 37856.,
      39128., 40400., 41672., 38132., 39416., 40700., 41984., 38408., 39704.,
      41000., 42296., 38684., 39992., 41300., 42608., 38960., 40280., 41600.,
      42920.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      172647., 173376., 226986., 227940., 228894., 229848., 169110., 169812.,
      170514., 171216., 219708., 220608., 288664., 289840., 291016., 292192.,
      214848., 215712., 216576., 217440., 234108., 235008., 307480., 308656.,
      309832., 311008., 228672., 229536., 230400., 231264., 162819., 163440.,
      213594., 214404., 215214., 216024., 158634., 159228., 159822., 160416.,
      172755., 173376., 226554., 227364., 228174., 228984., 168138., 168732.,
      169326., 169920.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15766., 15844., 15922., 16000., 16078., 16156., 16234., 16312., 16390.,
      16468., 17014., 17092., 17170., 17248., 17326., 17404., 17482., 17560.,
      17638., 17716., 18262., 18340., 18418., 18496., 18574., 18652., 18730.,
      18808., 18886., 18964., 19510., 19588., 19666., 19744., 19822., 19900.,
      19978., 20056., 20134., 20212., 20758., 20836., 20914., 20992., 21070.,
      21148., 21226., 21304., 21382., 21460.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      340353., 345294., 341784., 346752., 447384., 453972., 449256., 455880.,
      451128., 457788., 453000., 459696., 333225., 338220., 334602., 339624.,
      335979., 341028., 337356., 342432., 432828., 439416., 434592., 441216.,
      568544., 577328., 570848., 579680., 573152., 582032., 575456., 584384.,
      423036., 429696., 424728., 431424., 426420., 433152., 428112., 434880.,
      461052., 468216., 462816., 470016., 605408., 614960., 607712., 617312.,
      610016., 619664., 612320., 622016., 450108., 457344., 451800., 459072.,
      453492., 460800., 455184., 462528., 320265., 325638., 321480., 326880.,
      420024., 427188., 421608., 428808., 423192., 430428., 424776., 432048.,
      311841., 317268., 313002., 318456., 314163., 319644., 315324., 320832.,
      339705., 345510., 340920., 346752., 445368., 453108., 446952., 454728.,
      448536., 456348., 450120., 457968., 330417., 336276., 331578., 337464.,
      332739., 338652., 333900., 339840.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29768., 31532., 29912., 31688., 30056., 31844., 30200., 32000., 30344.,
      32156., 30488., 32312., 30632., 32468., 30776., 32624., 30920., 32780.,
      31064., 32936., 32072., 34028., 32216., 34184., 32360., 34340., 32504.,
      34496., 32648., 34652., 32792., 34808., 32936., 34964., 33080., 35120.,
      33224., 35276., 33368., 35432., 34376., 36524., 34520., 36680., 34664.,
      36836., 34808., 36992., 34952., 37148., 35096., 37304., 35240., 37460.,
      35384., 37616., 35528., 37772., 35672., 37928., 36680., 39020., 36824.,
      39176., 36968., 39332., 37112., 39488., 37256., 39644., 37400., 39800.,
      37544., 39956., 37688., 40112., 37832., 40268., 37976., 40424., 38984.,
      41516., 39128., 41672., 39272., 41828., 39416., 41984., 39560., 42140.,
      39704., 42296., 39848., 42452., 39992., 42608., 40136., 42764., 40280.,
      42920.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      675765.,  680706.,  685647.,  690588.,  678600.,  683568.,  688536.,
      693504.,  888180.,  894768.,  901356.,  907944.,  891888.,  898512.,
      905136.,  911760.,  895596.,  902256.,  908916.,  915576.,  899304.,
      906000.,  912696.,  919392.,  661455.,  666450.,  671445.,  676440.,
      664182.,  669204.,  674226.,  679248.,  666909.,  671958.,  677007.,
      682056.,  669636.,  674712.,  679788.,  684864.,  859068.,  865656.,
      872244.,  878832.,  862560.,  869184.,  875808.,  882432.,  1128304.,
      1137088., 1145872., 1154656., 1132864., 1141696., 1150528., 1159360.,
      1137424., 1146304., 1155184., 1164064., 1141984., 1150912., 1159840.,
      1168768., 839412.,  846072.,  852732.,  859392.,  842760.,  849456.,
      856152.,  862848.,  846108.,  852840.,  859572.,  866304.,  849456.,
      856224.,  862992.,  869760.,  914940.,  922104.,  929268.,  936432.,
      918432.,  925632.,  932832.,  940032.,  1201264., 1210816., 1220368.,
      1229920., 1205824., 1215424., 1225024., 1234624., 1210384., 1220032.,
      1229680., 1239328., 1214944., 1224640., 1234336., 1244032., 892980.,
      900216.,  907452.,  914688.,  896328.,  903600.,  910872.,  918144.,
      899676.,  906984.,  914292.,  921600.,  903024.,  910368.,  917712.,
      925056.,  635157.,  640530.,  645903.,  651276.,  637560.,  642960.,
      648360.,  653760.,  832884.,  840048.,  847212.,  854376.,  836016.,
      843216.,  850416.,  857616.,  839148.,  846384.,  853620.,  860856.,
      842280.,  849552.,  856824.,  864096.,  618255.,  623682.,  629109.,
      634536.,  620550.,  626004.,  631458.,  636912.,  622845.,  628326.,
      633807.,  639288.,  625140.,  630648.,  636156.,  641664.,  673605.,
      679410.,  685215.,  691020.,  676008.,  681840.,  687672.,  693504.,
      882996.,  890736.,  898476.,  906216.,  886128.,  893904.,  901680.,
      909456.,  889260.,  897072.,  904884.,  912696.,  892392.,  900240.,
      908088.,  915936.,  654975.,  660834.,  666693.,  672552.,  657270.,
      663156.,  669042.,  674928.,  659565.,  665478.,  671391.,  677304.,
      661860.,  667800.,  673740.,  679680.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57772., 59536., 61300., 63064., 58048., 59824., 61600., 63376., 58324.,
      60112., 61900., 63688., 58600., 60400., 62200., 64000., 58876., 60688.,
      62500., 64312., 59152., 60976., 62800., 64624., 59428., 61264., 63100.,
      64936., 59704., 61552., 63400., 65248., 59980., 61840., 63700., 65560.,
      60256., 62128., 64000., 65872., 62188., 64144., 66100., 68056., 62464.,
      64432., 66400., 68368., 62740., 64720., 66700., 68680., 63016., 65008.,
      67000., 68992., 63292., 65296., 67300., 69304., 63568., 65584., 67600.,
      69616., 63844., 65872., 67900., 69928., 64120., 66160., 68200., 70240.,
      64396., 66448., 68500., 70552., 64672., 66736., 68800., 70864., 66604.,
      68752., 70900., 73048., 66880., 69040., 71200., 73360., 67156., 69328.,
      71500., 73672., 67432., 69616., 71800., 73984., 67708., 69904., 72100.,
      74296., 67984., 70192., 72400., 74608., 68260., 70480., 72700., 74920.,
      68536., 70768., 73000., 75232., 68812., 71056., 73300., 75544., 69088.,
      71344., 73600., 75856., 71020., 73360., 75700., 78040., 71296., 73648.,
      76000., 78352., 71572., 73936., 76300., 78664., 71848., 74224., 76600.,
      78976., 72124., 74512., 76900., 79288., 72400., 74800., 77200., 79600.,
      72676., 75088., 77500., 79912., 72952., 75376., 77800., 80224., 73228.,
      75664., 78100., 80536., 73504., 75952., 78400., 80848., 75436., 77968.,
      80500., 83032., 75712., 78256., 80800., 83344., 75988., 78544., 81100.,
      83656., 76264., 78832., 81400., 83968., 76540., 79120., 81700., 84280.,
      76816., 79408., 82000., 84592., 77092., 79696., 82300., 84904., 77368.,
      79984., 82600., 85216., 77644., 80272., 82900., 85528., 77920., 80560.,
      83200., 85840.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344565., 345294., 346023., 346752., 453018., 453972., 454926., 455880.,
      456834., 457788., 458742., 459696., 337518., 338220., 338922., 339624.,
      340326., 341028., 341730., 342432., 438516., 439416., 440316., 441216.,
      576152., 577328., 578504., 579680., 580856., 582032., 583208., 584384.,
      428832., 429696., 430560., 431424., 432288., 433152., 434016., 434880.,
      467316., 468216., 469116., 470016., 613784., 614960., 616136., 617312.,
      618488., 619664., 620840., 622016., 456480., 457344., 458208., 459072.,
      459936., 460800., 461664., 462528., 325017., 325638., 326259., 326880.,
      426378., 427188., 427998., 428808., 429618., 430428., 431238., 432048.,
      316674., 317268., 317862., 318456., 319050., 319644., 320238., 320832.,
      344889., 345510., 346131., 346752., 452298., 453108., 453918., 454728.,
      455538., 456348., 457158., 457968., 335682., 336276., 336870., 337464.,
      338058., 338652., 339246., 339840.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31454., 31532., 31610., 31688., 31766., 31844., 31922., 32000., 32078.,
      32156., 32234., 32312., 32390., 32468., 32546., 32624., 32702., 32780.,
      32858., 32936., 33950., 34028., 34106., 34184., 34262., 34340., 34418.,
      34496., 34574., 34652., 34730., 34808., 34886., 34964., 35042., 35120.,
      35198., 35276., 35354., 35432., 36446., 36524., 36602., 36680., 36758.,
      36836., 36914., 36992., 37070., 37148., 37226., 37304., 37382., 37460.,
      37538., 37616., 37694., 37772., 37850., 37928., 38942., 39020., 39098.,
      39176., 39254., 39332., 39410., 39488., 39566., 39644., 39722., 39800.,
      39878., 39956., 40034., 40112., 40190., 40268., 40346., 40424., 41438.,
      41516., 41594., 41672., 41750., 41828., 41906., 41984., 42062., 42140.,
      42218., 42296., 42374., 42452., 42530., 42608., 42686., 42764., 42842.,
      42920.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      679275.,  689130.,  680706.,  690588.,  682137.,  692046.,  683568.,
      693504.,  892896.,  906036.,  894768.,  907944.,  896640.,  909852.,
      898512.,  911760.,  900384.,  913668.,  902256.,  915576.,  904128.,
      917484.,  906000.,  919392.,  665073.,  675036.,  666450.,  676440.,
      667827.,  677844.,  669204.,  679248.,  670581.,  680652.,  671958.,
      682056.,  673335.,  683460.,  674712.,  684864.,  863892.,  877032.,
      865656.,  878832.,  867420.,  880632.,  869184.,  882432.,  1134784.,
      1152304., 1137088., 1154656., 1139392., 1157008., 1141696., 1159360.,
      1144000., 1161712., 1146304., 1164064., 1148608., 1166416., 1150912.,
      1168768., 844380.,  857664.,  846072.,  859392.,  847764.,  861120.,
      849456.,  862848.,  851148.,  864576.,  852840.,  866304.,  854532.,
      868032.,  856224.,  869760.,  920340.,  934632.,  922104.,  936432.,
      923868.,  938232.,  925632.,  940032.,  1208512., 1227568., 1210816.,
      1229920., 1213120., 1232272., 1215424., 1234624., 1217728., 1236976.,
      1220032., 1239328., 1222336., 1241680., 1224640., 1244032., 898524.,
      912960.,  900216.,  914688.,  901908.,  916416.,  903600.,  918144.,
      905292.,  919872.,  906984.,  921600.,  908676.,  923328.,  910368.,
      925056.,  639315.,  650034.,  640530.,  651276.,  641745.,  652518.,
      642960.,  653760.,  838464.,  852756.,  840048.,  854376.,  841632.,
      855996.,  843216.,  857616.,  844800.,  859236.,  846384.,  860856.,
      847968.,  862476.,  849552.,  864096.,  622521.,  633348.,  623682.,
      634536.,  624843.,  635724.,  626004.,  636912.,  627165.,  638100.,
      628326.,  639288.,  629487.,  640476.,  630648.,  641664.,  678195.,
      689778.,  679410.,  691020.,  680625.,  692262.,  681840.,  693504.,
      889152.,  904596.,  890736.,  906216.,  892320.,  907836.,  893904.,
      909456.,  895488.,  911076.,  897072.,  912696.,  898656.,  914316.,
      900240.,  915936.,  659673.,  671364.,  660834.,  672552.,  661995.,
      673740.,  663156.,  674928.,  664317.,  676116.,  665478.,  677304.,
      666639.,  678492.,  667800.,  679680.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      59392., 62908., 59536., 63064., 59680., 63220., 59824., 63376., 59968.,
      63532., 60112., 63688., 60256., 63844., 60400., 64000., 60544., 64156.,
      60688., 64312., 60832., 64468., 60976., 64624., 61120., 64780., 61264.,
      64936., 61408., 65092., 61552., 65248., 61696., 65404., 61840., 65560.,
      61984., 65716., 62128., 65872., 64000., 67900., 64144., 68056., 64288.,
      68212., 64432., 68368., 64576., 68524., 64720., 68680., 64864., 68836.,
      65008., 68992., 65152., 69148., 65296., 69304., 65440., 69460., 65584.,
      69616., 65728., 69772., 65872., 69928., 66016., 70084., 66160., 70240.,
      66304., 70396., 66448., 70552., 66592., 70708., 66736., 70864., 68608.,
      72892., 68752., 73048., 68896., 73204., 69040., 73360., 69184., 73516.,
      69328., 73672., 69472., 73828., 69616., 73984., 69760., 74140., 69904.,
      74296., 70048., 74452., 70192., 74608., 70336., 74764., 70480., 74920.,
      70624., 75076., 70768., 75232., 70912., 75388., 71056., 75544., 71200.,
      75700., 71344., 75856., 73216., 77884., 73360., 78040., 73504., 78196.,
      73648., 78352., 73792., 78508., 73936., 78664., 74080., 78820., 74224.,
      78976., 74368., 79132., 74512., 79288., 74656., 79444., 74800., 79600.,
      74944., 79756., 75088., 79912., 75232., 80068., 75376., 80224., 75520.,
      80380., 75664., 80536., 75808., 80692., 75952., 80848., 77824., 82876.,
      77968., 83032., 78112., 83188., 78256., 83344., 78400., 83500., 78544.,
      83656., 78688., 83812., 78832., 83968., 78976., 84124., 79120., 84280.,
      79264., 84436., 79408., 84592., 79552., 84748., 79696., 84904., 79840.,
      85060., 79984., 85216., 80128., 85372., 80272., 85528., 80416., 85684.,
      80560., 85840.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1348695., 1358550., 1368405., 1378260., 1351530., 1361412., 1371294.,
      1381176., 1354365., 1364274., 1374183., 1384092., 1357200., 1367136.,
      1377072., 1387008., 1772652., 1785792., 1798932., 1812072., 1776360.,
      1789536., 1802712., 1815888., 1780068., 1793280., 1806492., 1819704.,
      1783776., 1797024., 1810272., 1823520., 1787484., 1800768., 1814052.,
      1827336., 1791192., 1804512., 1817832., 1831152., 1794900., 1808256.,
      1821612., 1834968., 1798608., 1812000., 1825392., 1838784., 1320183.,
      1330146., 1340109., 1350072., 1322910., 1332900., 1342890., 1352880.,
      1325637., 1335654., 1345671., 1355688., 1328364., 1338408., 1348452.,
      1358496., 1331091., 1341162., 1351233., 1361304., 1333818., 1343916.,
      1354014., 1364112., 1336545., 1346670., 1356795., 1366920., 1339272.,
      1349424., 1359576., 1369728., 1714644., 1727784., 1740924., 1754064.,
      1718136., 1731312., 1744488., 1757664., 1721628., 1734840., 1748052.,
      1761264., 1725120., 1738368., 1751616., 1764864., 2252048., 2269568.,
      2287088., 2304608., 2256608., 2274176., 2291744., 2309312., 2261168.,
      2278784., 2296400., 2314016., 2265728., 2283392., 2301056., 2318720.,
      2270288., 2288000., 2305712., 2323424., 2274848., 2292608., 2310368.,
      2328128., 2279408., 2297216., 2315024., 2332832., 2283968., 2301824.,
      2319680., 2337536., 1675476., 1688760., 1702044., 1715328., 1678824.,
      1692144., 1705464., 1718784., 1682172., 1695528., 1708884., 1722240.,
      1685520., 1698912., 1712304., 1725696., 1688868., 1702296., 1715724.,
      1729152., 1692216., 1705680., 1719144., 1732608., 1695564., 1709064.,
      1722564., 1736064., 1698912., 1712448., 1725984., 1739520., 1826388.,
      1840680., 1854972., 1869264., 1829880., 1844208., 1858536., 1872864.,
      1833372., 1847736., 1862100., 1876464., 1836864., 1851264., 1865664.,
      1880064., 2397968., 2417024., 2436080., 2455136., 2402528., 2421632.,
      2440736., 2459840., 2407088., 2426240., 2445392., 2464544., 2411648.,
      2430848., 2450048., 2469248., 2416208., 2435456., 2454704., 2473952.,
      2420768., 2440064., 2459360., 2478656., 2425328., 2444672., 2464016.,
      2483360., 2429888., 2449280., 2468672., 2488064., 1782612., 1797048.,
      1811484., 1825920., 1785960., 1800432., 1814904., 1829376., 1789308.,
      1803816., 1818324., 1832832., 1792656., 1807200., 1821744., 1836288.,
      1796004., 1810584., 1825164., 1839744., 1799352., 1813968., 1828584.,
      1843200., 1802700., 1817352., 1832004., 1846656., 1806048., 1820736.,
      1835424., 1850112., 1267911., 1278630., 1289349., 1300068., 1270314.,
      1281060., 1291806., 1302552., 1272717., 1283490., 1294263., 1305036.,
      1275120., 1285920., 1296720., 1307520., 1662636., 1676928., 1691220.,
      1705512., 1665768., 1680096., 1694424., 1708752., 1668900., 1683264.,
      1697628., 1711992., 1672032., 1686432., 1700832., 1715232., 1675164.,
      1689600., 1704036., 1718472., 1678296., 1692768., 1707240., 1721712.,
      1681428., 1695936., 1710444., 1724952., 1684560., 1699104., 1713648.,
      1728192., 1234215., 1245042., 1255869., 1266696., 1236510., 1247364.,
      1258218., 1269072., 1238805., 1249686., 1260567., 1271448., 1241100.,
      1252008., 1262916., 1273824., 1243395., 1254330., 1265265., 1276200.,
      1245690., 1256652., 1267614., 1278576., 1247985., 1258974., 1269963.,
      1280952., 1250280., 1261296., 1272312., 1283328., 1344807., 1356390.,
      1367973., 1379556., 1347210., 1358820., 1370430., 1382040., 1349613.,
      1361250., 1372887., 1384524., 1352016., 1363680., 1375344., 1387008.,
      1762860., 1778304., 1793748., 1809192., 1765992., 1781472., 1796952.,
      1812432., 1769124., 1784640., 1800156., 1815672., 1772256., 1787808.,
      1803360., 1818912., 1775388., 1790976., 1806564., 1822152., 1778520.,
      1794144., 1809768., 1825392., 1781652., 1797312., 1812972., 1828632.,
      1784784., 1800480., 1816176., 1831872., 1307655., 1319346., 1331037.,
      1342728., 1309950., 1321668., 1333386., 1345104., 1312245., 1323990.,
      1335735., 1347480., 1314540., 1326312., 1338084., 1349856., 1316835.,
      1328634., 1340433., 1352232., 1319130., 1330956., 1342782., 1354608.,
      1321425., 1333278., 1345131., 1356984., 1323720., 1335600., 1347480.,
      1359360.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115268., 118784., 122300., 125816., 115544., 119072., 122600., 126128.,
      115820., 119360., 122900., 126440., 116096., 119648., 123200., 126752.,
      116372., 119936., 123500., 127064., 116648., 120224., 123800., 127376.,
      116924., 120512., 124100., 127688., 117200., 120800., 124400., 128000.,
      117476., 121088., 124700., 128312., 117752., 121376., 125000., 128624.,
      118028., 121664., 125300., 128936., 118304., 121952., 125600., 129248.,
      118580., 122240., 125900., 129560., 118856., 122528., 126200., 129872.,
      119132., 122816., 126500., 130184., 119408., 123104., 126800., 130496.,
      119684., 123392., 127100., 130808., 119960., 123680., 127400., 131120.,
      120236., 123968., 127700., 131432., 120512., 124256., 128000., 131744.,
      124100., 128000., 131900., 135800., 124376., 128288., 132200., 136112.,
      124652., 128576., 132500., 136424., 124928., 128864., 132800., 136736.,
      125204., 129152., 133100., 137048., 125480., 129440., 133400., 137360.,
      125756., 129728., 133700., 137672., 126032., 130016., 134000., 137984.,
      126308., 130304., 134300., 138296., 126584., 130592., 134600., 138608.,
      126860., 130880., 134900., 138920., 127136., 131168., 135200., 139232.,
      127412., 131456., 135500., 139544., 127688., 131744., 135800., 139856.,
      127964., 132032., 136100., 140168., 128240., 132320., 136400., 140480.,
      128516., 132608., 136700., 140792., 128792., 132896., 137000., 141104.,
      129068., 133184., 137300., 141416., 129344., 133472., 137600., 141728.,
      132932., 137216., 141500., 145784., 133208., 137504., 141800., 146096.,
      133484., 137792., 142100., 146408., 133760., 138080., 142400., 146720.,
      134036., 138368., 142700., 147032., 134312., 138656., 143000., 147344.,
      134588., 138944., 143300., 147656., 134864., 139232., 143600., 147968.,
      135140., 139520., 143900., 148280., 135416., 139808., 144200., 148592.,
      135692., 140096., 144500., 148904., 135968., 140384., 144800., 149216.,
      136244., 140672., 145100., 149528., 136520., 140960., 145400., 149840.,
      136796., 141248., 145700., 150152., 137072., 141536., 146000., 150464.,
      137348., 141824., 146300., 150776., 137624., 142112., 146600., 151088.,
      137900., 142400., 146900., 151400., 138176., 142688., 147200., 151712.,
      141764., 146432., 151100., 155768., 142040., 146720., 151400., 156080.,
      142316., 147008., 151700., 156392., 142592., 147296., 152000., 156704.,
      142868., 147584., 152300., 157016., 143144., 147872., 152600., 157328.,
      143420., 148160., 152900., 157640., 143696., 148448., 153200., 157952.,
      143972., 148736., 153500., 158264., 144248., 149024., 153800., 158576.,
      144524., 149312., 154100., 158888., 144800., 149600., 154400., 159200.,
      145076., 149888., 154700., 159512., 145352., 150176., 155000., 159824.,
      145628., 150464., 155300., 160136., 145904., 150752., 155600., 160448.,
      146180., 151040., 155900., 160760., 146456., 151328., 156200., 161072.,
      146732., 151616., 156500., 161384., 147008., 151904., 156800., 161696.,
      150596., 155648., 160700., 165752., 150872., 155936., 161000., 166064.,
      151148., 156224., 161300., 166376., 151424., 156512., 161600., 166688.,
      151700., 156800., 161900., 167000., 151976., 157088., 162200., 167312.,
      152252., 157376., 162500., 167624., 152528., 157664., 162800., 167936.,
      152804., 157952., 163100., 168248., 153080., 158240., 163400., 168560.,
      153356., 158528., 163700., 168872., 153632., 158816., 164000., 169184.,
      153908., 159104., 164300., 169496., 154184., 159392., 164600., 169808.,
      154460., 159680., 164900., 170120., 154736., 159968., 165200., 170432.,
      155012., 160256., 165500., 170744., 155288., 160544., 165800., 171056.,
      155564., 160832., 166100., 171368., 155840., 161120., 166400., 171680.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      179580., 221955., 223440., 176610., 177780., 228440., 282190.,
      284020., 224360., 225800., 243320., 300490., 302320., 238760.,
      240200., 169140., 208680., 209940., 165630., 166620., 179400.,
      221280., 222540., 175530., 176520.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21957., 22128., 22299., 22470., 22641., 23667., 23838., 24009., 24180.,
      24351., 25377., 25548., 25719., 25890., 26061., 27087., 27258., 27429.,
      27600., 27771., 28797., 28968., 29139., 29310., 29481.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      355020., 359160., 438735., 443910., 441660., 446880., 349044., 353220.,
      351348., 355560., 451360., 456880., 557480., 564380., 561080., 568040.,
      443152., 448720., 445984., 451600., 480640., 486640., 593480., 600980.,
      597080., 604640., 471472., 477520., 474304., 480400., 333780., 338280.,
      411735., 417360., 414210., 419880., 326724., 331260., 328668., 333240.,
      353940., 358800., 436485., 442560., 438960., 445080., 346164., 351060.,
      348108., 353040.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42240., 43914., 42564., 44256., 42888., 44598., 43212., 44940., 43536.,
      45282., 45480., 47334., 45804., 47676., 46128., 48018., 46452., 48360.,
      46776., 48702., 48720., 50754., 49044., 51096., 49368., 51438., 49692.,
      51780., 50016., 52122., 51960., 54174., 52284., 54516., 52608., 54858.,
      52932., 55200., 53256., 55542., 55200., 57594., 55524., 57936., 55848.,
      58278., 56172., 58620., 56496., 58962.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      705900.,  710040.,  714180.,  718320.,  872295.,  877470.,  882645.,
      887820.,  878100.,  883320.,  888540.,  893760.,  693912.,  698088.,
      702264.,  706440.,  698484.,  702696.,  706908.,  711120.,  897200.,
      902720.,  908240.,  913760.,  1108060., 1114960., 1121860., 1128760.,
      1115200., 1122160., 1129120., 1136080., 880736.,  886304.,  891872.,
      897440.,  886352.,  891968.,  897584.,  903200.,  955280.,  961280.,
      967280.,  973280.,  1179460., 1186960., 1194460., 1201960., 1186600.,
      1194160., 1201720., 1209280., 936896.,  942944.,  948992.,  955040.,
      942512.,  948608.,  954704.,  960800.,  663060.,  667560.,  672060.,
      676560.,  817845.,  823470.,  829095.,  834720.,  822750.,  828420.,
      834090.,  839760.,  648912.,  653448.,  657984.,  662520.,  652764.,
      657336.,  661908.,  666480.,  703020.,  707880.,  712740.,  717600.,
      866895.,  872970.,  879045.,  885120.,  871800.,  877920.,  884040.,
      890160.,  687432.,  692328.,  697224.,  702120.,  691284.,  696216.,
      701148.,  706080.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      82806.,  84480.,  86154.,  87828.,  83436.,  85128.,  86820.,  88512.,
      84066.,  85776.,  87486.,  89196.,  84696.,  86424.,  88152.,  89880.,
      85326.,  87072.,  88818.,  90564.,  89106.,  90960.,  92814.,  94668.,
      89736.,  91608.,  93480.,  95352.,  90366.,  92256.,  94146.,  96036.,
      90996.,  92904.,  94812.,  96720.,  91626.,  93552.,  95478.,  97404.,
      95406.,  97440.,  99474.,  101508., 96036.,  98088.,  100140., 102192.,
      96666.,  98736.,  100806., 102876., 97296.,  99384.,  101472., 103560.,
      97926.,  100032., 102138., 104244., 101706., 103920., 106134., 108348.,
      102336., 104568., 106800., 109032., 102966., 105216., 107466., 109716.,
      103596., 105864., 108132., 110400., 104226., 106512., 108798., 111084.,
      108006., 110400., 112794., 115188., 108636., 111048., 113460., 115872.,
      109266., 111696., 114126., 116556., 109896., 112344., 114792., 117240.,
      110526., 112992., 115458., 117924.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      357954., 359160., 442425., 443910., 445395., 446880., 352050., 353220.,
      354390., 355560., 455392., 456880., 562550., 564380., 566210., 568040.,
      447280., 448720., 450160., 451600., 485152., 486640., 599150., 600980.,
      602810., 604640., 476080., 477520., 478960., 480400., 337254., 338280.,
      416100., 417360., 418620., 419880., 330270., 331260., 332250., 333240.,
      357774., 358800., 441300., 442560., 443820., 445080., 350070., 351060.,
      352050., 353040.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      43743., 43914., 44085., 44256., 44427., 44598., 44769., 44940., 45111.,
      45282., 47163., 47334., 47505., 47676., 47847., 48018., 48189., 48360.,
      48531., 48702., 50583., 50754., 50925., 51096., 51267., 51438., 51609.,
      51780., 51951., 52122., 54003., 54174., 54345., 54516., 54687., 54858.,
      55029., 55200., 55371., 55542., 57423., 57594., 57765., 57936., 58107.,
      58278., 58449., 58620., 58791., 58962.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      707664.,  715908.,  710040.,  718320.,  874545.,  884850.,  877470.,
      887820.,  880395.,  890790.,  883320.,  893760.,  695784.,  704100.,
      698088.,  706440.,  700392.,  708780.,  702696.,  711120.,  899792.,
      910784.,  902720.,  913760.,  1111360., 1125100., 1114960., 1128760.,
      1118560., 1132420., 1122160., 1136080., 883472.,  894560.,  886304.,
      897440.,  889136.,  900320.,  891968.,  903200.,  958352.,  970304.,
      961280.,  973280.,  1183360., 1198300., 1186960., 1201960., 1190560.,
      1205620., 1194160., 1209280., 940112.,  952160.,  942944.,  955040.,
      945776.,  957920.,  948608.,  960800.,  665544.,  674508.,  667560.,
      676560.,  820995.,  832200.,  823470.,  834720.,  825945.,  837240.,
      828420.,  839760.,  651504.,  660540.,  653448.,  662520.,  655392.,
      664500.,  657336.,  666480.,  705864.,  715548.,  707880.,  717600.,
      870495.,  882600.,  872970.,  885120.,  875445.,  887640.,  877920.,
      890160.,  690384.,  700140.,  692328.,  702120.,  694272.,  704100.,
      696216.,  706080.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84156.,  87486.,  84480.,  87828.,  84804.,  88170.,  85128.,  88512.,
      85452.,  88854.,  85776.,  89196.,  86100.,  89538.,  86424.,  89880.,
      86748.,  90222.,  87072.,  90564.,  90636.,  94326.,  90960.,  94668.,
      91284.,  95010.,  91608.,  95352.,  91932.,  95694.,  92256.,  96036.,
      92580.,  96378.,  92904.,  96720.,  93228.,  97062.,  93552.,  97404.,
      97116.,  101166., 97440.,  101508., 97764.,  101850., 98088.,  102192.,
      98412.,  102534., 98736.,  102876., 99060.,  103218., 99384.,  103560.,
      99708.,  103902., 100032., 104244., 103596., 108006., 103920., 108348.,
      104244., 108690., 104568., 109032., 104892., 109374., 105216., 109716.,
      105540., 110058., 105864., 110400., 106188., 110742., 106512., 111084.,
      110076., 114846., 110400., 115188., 110724., 115530., 111048., 115872.,
      111372., 116214., 111696., 116556., 112020., 116898., 112344., 117240.,
      112668., 117582., 112992., 117924.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1407084., 1415328., 1423572., 1431816., 1411800., 1420080., 1428360.,
      1436640., 1738785., 1749090., 1759395., 1769700., 1744590., 1754940.,
      1765290., 1775640., 1750395., 1760790., 1771185., 1781580., 1756200.,
      1766640., 1777080., 1787520., 1383252., 1391568., 1399884., 1408200.,
      1387824., 1396176., 1404528., 1412880., 1392396., 1400784., 1409172.,
      1417560., 1396968., 1405392., 1413816., 1422240., 1788592., 1799584.,
      1810576., 1821568., 1794400., 1805440., 1816480., 1827520., 2208980.,
      2222720., 2236460., 2250200., 2216120., 2229920., 2243720., 2257520.,
      2223260., 2237120., 2250980., 2264840., 2230400., 2244320., 2258240.,
      2272160., 1755856., 1766944., 1778032., 1789120., 1761472., 1772608.,
      1783744., 1794880., 1767088., 1778272., 1789456., 1800640., 1772704.,
      1783936., 1795168., 1806400., 1904752., 1916704., 1928656., 1940608.,
      1910560., 1922560., 1934560., 1946560., 2351780., 2366720., 2381660.,
      2396600., 2358920., 2373920., 2388920., 2403920., 2366060., 2381120.,
      2396180., 2411240., 2373200., 2388320., 2403440., 2418560., 1868176.,
      1880224., 1892272., 1904320., 1873792., 1885888., 1897984., 1910080.,
      1879408., 1891552., 1903696., 1915840., 1885024., 1897216., 1909408.,
      1921600., 1322124., 1331088., 1340052., 1349016., 1326120., 1335120.,
      1344120., 1353120., 1630785., 1641990., 1653195., 1664400., 1635690.,
      1646940., 1658190., 1669440., 1640595., 1651890., 1663185., 1674480.,
      1645500., 1656840., 1668180., 1679520., 1293972., 1303008., 1312044.,
      1321080., 1297824., 1306896., 1315968., 1325040., 1301676., 1310784.,
      1319892., 1329000., 1305528., 1314672., 1323816., 1332960., 1402044.,
      1411728., 1421412., 1431096., 1406040., 1415760., 1425480., 1435200.,
      1728885., 1740990., 1753095., 1765200., 1733790., 1745940., 1758090.,
      1770240., 1738695., 1750890., 1763085., 1775280., 1743600., 1755840.,
      1768080., 1780320., 1371012., 1380768., 1390524., 1400280., 1374864.,
      1384656., 1394448., 1404240., 1378716., 1388544., 1398372., 1408200.,
      1382568., 1392432., 1402296., 1412160.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      164982., 168312., 171642., 174972., 165612., 168960., 172308., 175656.,
      166242., 169608., 172974., 176340., 166872., 170256., 173640., 177024.,
      167502., 170904., 174306., 177708., 168132., 171552., 174972., 178392.,
      168762., 172200., 175638., 179076., 169392., 172848., 176304., 179760.,
      170022., 173496., 176970., 180444., 170652., 174144., 177636., 181128.,
      177582., 181272., 184962., 188652., 178212., 181920., 185628., 189336.,
      178842., 182568., 186294., 190020., 179472., 183216., 186960., 190704.,
      180102., 183864., 187626., 191388., 180732., 184512., 188292., 192072.,
      181362., 185160., 188958., 192756., 181992., 185808., 189624., 193440.,
      182622., 186456., 190290., 194124., 183252., 187104., 190956., 194808.,
      190182., 194232., 198282., 202332., 190812., 194880., 198948., 203016.,
      191442., 195528., 199614., 203700., 192072., 196176., 200280., 204384.,
      192702., 196824., 200946., 205068., 193332., 197472., 201612., 205752.,
      193962., 198120., 202278., 206436., 194592., 198768., 202944., 207120.,
      195222., 199416., 203610., 207804., 195852., 200064., 204276., 208488.,
      202782., 207192., 211602., 216012., 203412., 207840., 212268., 216696.,
      204042., 208488., 212934., 217380., 204672., 209136., 213600., 218064.,
      205302., 209784., 214266., 218748., 205932., 210432., 214932., 219432.,
      206562., 211080., 215598., 220116., 207192., 211728., 216264., 220800.,
      207822., 212376., 216930., 221484., 208452., 213024., 217596., 222168.,
      215382., 220152., 224922., 229692., 216012., 220800., 225588., 230376.,
      216642., 221448., 226254., 231060., 217272., 222096., 226920., 231744.,
      217902., 222744., 227586., 232428., 218532., 223392., 228252., 233112.,
      219162., 224040., 228918., 233796., 219792., 224688., 229584., 234480.,
      220422., 225336., 230250., 235164., 221052., 225984., 230916., 235848.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      714702.,  715908.,  717114.,  718320.,  883365.,  884850.,  886335.,
      887820.,  889305.,  890790.,  892275.,  893760.,  702930.,  704100.,
      705270.,  706440.,  707610.,  708780.,  709950.,  711120.,  909296.,
      910784.,  912272.,  913760.,  1123270., 1125100., 1126930., 1128760.,
      1130590., 1132420., 1134250., 1136080., 893120.,  894560.,  896000.,
      897440.,  898880.,  900320.,  901760.,  903200.,  968816.,  970304.,
      971792.,  973280.,  1196470., 1198300., 1200130., 1201960., 1203790.,
      1205620., 1207450., 1209280., 950720.,  952160.,  953600.,  955040.,
      956480.,  957920.,  959360.,  960800.,  673482.,  674508.,  675534.,
      676560.,  830940.,  832200.,  833460.,  834720.,  835980.,  837240.,
      838500.,  839760.,  659550.,  660540.,  661530.,  662520.,  663510.,
      664500.,  665490.,  666480.,  714522.,  715548.,  716574.,  717600.,
      881340.,  882600.,  883860.,  885120.,  886380.,  887640.,  888900.,
      890160.,  699150.,  700140.,  701130.,  702120.,  703110.,  704100.,
      705090.,  706080.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      87315.,  87486.,  87657.,  87828.,  87999.,  88170.,  88341.,  88512.,
      88683.,  88854.,  89025.,  89196.,  89367.,  89538.,  89709.,  89880.,
      90051.,  90222.,  90393.,  90564.,  94155.,  94326.,  94497.,  94668.,
      94839.,  95010.,  95181.,  95352.,  95523.,  95694.,  95865.,  96036.,
      96207.,  96378.,  96549.,  96720.,  96891.,  97062.,  97233.,  97404.,
      100995., 101166., 101337., 101508., 101679., 101850., 102021., 102192.,
      102363., 102534., 102705., 102876., 103047., 103218., 103389., 103560.,
      103731., 103902., 104073., 104244., 107835., 108006., 108177., 108348.,
      108519., 108690., 108861., 109032., 109203., 109374., 109545., 109716.,
      109887., 110058., 110229., 110400., 110571., 110742., 110913., 111084.,
      114675., 114846., 115017., 115188., 115359., 115530., 115701., 115872.,
      116043., 116214., 116385., 116556., 116727., 116898., 117069., 117240.,
      117411., 117582., 117753., 117924.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1412952., 1429404., 1415328., 1431816., 1417704., 1434228., 1420080.,
      1436640., 1746165., 1766730., 1749090., 1769700., 1752015., 1772670.,
      1754940., 1775640., 1757865., 1778610., 1760790., 1781580., 1763715.,
      1784550., 1766640., 1787520., 1389264., 1405860., 1391568., 1408200.,
      1393872., 1410540., 1396176., 1412880., 1398480., 1415220., 1400784.,
      1417560., 1403088., 1419900., 1405392., 1422240., 1796656., 1818592.,
      1799584., 1821568., 1802512., 1824544., 1805440., 1827520., 2219120.,
      2246540., 2222720., 2250200., 2226320., 2253860., 2229920., 2257520.,
      2233520., 2261180., 2237120., 2264840., 2240720., 2268500., 2244320.,
      2272160., 1764112., 1786240., 1766944., 1789120., 1769776., 1792000.,
      1772608., 1794880., 1775440., 1797760., 1778272., 1800640., 1781104.,
      1803520., 1783936., 1806400., 1913776., 1937632., 1916704., 1940608.,
      1919632., 1943584., 1922560., 1946560., 2363120., 2392940., 2366720.,
      2396600., 2370320., 2400260., 2373920., 2403920., 2377520., 2407580.,
      2381120., 2411240., 2384720., 2414900., 2388320., 2418560., 1877392.,
      1901440., 1880224., 1904320., 1883056., 1907200., 1885888., 1910080.,
      1888720., 1912960., 1891552., 1915840., 1894384., 1918720., 1897216.,
      1921600., 1329072., 1346964., 1331088., 1349016., 1333104., 1351068.,
      1335120., 1353120., 1639515., 1661880., 1641990., 1664400., 1644465.,
      1666920., 1646940., 1669440., 1649415., 1671960., 1651890., 1674480.,
      1654365., 1677000., 1656840., 1679520., 1301064., 1319100., 1303008.,
      1321080., 1304952., 1323060., 1306896., 1325040., 1308840., 1327020.,
      1310784., 1329000., 1312728., 1330980., 1314672., 1332960., 1409712.,
      1429044., 1411728., 1431096., 1413744., 1433148., 1415760., 1435200.,
      1738515., 1762680., 1740990., 1765200., 1743465., 1767720., 1745940.,
      1770240., 1748415., 1772760., 1750890., 1775280., 1753365., 1777800.,
      1755840., 1780320., 1378824., 1398300., 1380768., 1400280., 1382712.,
      1402260., 1384656., 1404240., 1386600., 1406220., 1388544., 1408200.,
      1390488., 1410180., 1392432., 1412160.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      167988., 174630., 168312., 174972., 168636., 175314., 168960., 175656.,
      169284., 175998., 169608., 176340., 169932., 176682., 170256., 177024.,
      170580., 177366., 170904., 177708., 171228., 178050., 171552., 178392.,
      171876., 178734., 172200., 179076., 172524., 179418., 172848., 179760.,
      173172., 180102., 173496., 180444., 173820., 180786., 174144., 181128.,
      180948., 188310., 181272., 188652., 181596., 188994., 181920., 189336.,
      182244., 189678., 182568., 190020., 182892., 190362., 183216., 190704.,
      183540., 191046., 183864., 191388., 184188., 191730., 184512., 192072.,
      184836., 192414., 185160., 192756., 185484., 193098., 185808., 193440.,
      186132., 193782., 186456., 194124., 186780., 194466., 187104., 194808.,
      193908., 201990., 194232., 202332., 194556., 202674., 194880., 203016.,
      195204., 203358., 195528., 203700., 195852., 204042., 196176., 204384.,
      196500., 204726., 196824., 205068., 197148., 205410., 197472., 205752.,
      197796., 206094., 198120., 206436., 198444., 206778., 198768., 207120.,
      199092., 207462., 199416., 207804., 199740., 208146., 200064., 208488.,
      206868., 215670., 207192., 216012., 207516., 216354., 207840., 216696.,
      208164., 217038., 208488., 217380., 208812., 217722., 209136., 218064.,
      209460., 218406., 209784., 218748., 210108., 219090., 210432., 219432.,
      210756., 219774., 211080., 220116., 211404., 220458., 211728., 220800.,
      212052., 221142., 212376., 221484., 212700., 221826., 213024., 222168.,
      219828., 229350., 220152., 229692., 220476., 230034., 220800., 230376.,
      221124., 230718., 221448., 231060., 221772., 231402., 222096., 231744.,
      222420., 232086., 222744., 232428., 223068., 232770., 223392., 233112.,
      223716., 233454., 224040., 233796., 224364., 234138., 224688., 234480.,
      225012., 234822., 225336., 235164., 225660., 235506., 225984., 235848.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x8x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2809452., 2825904., 2842356., 2858808., 2814168., 2830656., 2847144.,
      2863632., 2818884., 2835408., 2851932., 2868456., 2823600., 2840160.,
      2856720., 2873280., 3471765., 3492330., 3512895., 3533460., 3477570.,
      3498180., 3518790., 3539400., 3483375., 3504030., 3524685., 3545340.,
      3489180., 3509880., 3530580., 3551280., 3494985., 3515730., 3536475.,
      3557220., 3500790., 3521580., 3542370., 3563160., 3506595., 3527430.,
      3548265., 3569100., 3512400., 3533280., 3554160., 3575040., 2761932.,
      2778528., 2795124., 2811720., 2766504., 2783136., 2799768., 2816400.,
      2771076., 2787744., 2804412., 2821080., 2775648., 2792352., 2809056.,
      2825760., 2780220., 2796960., 2813700., 2830440., 2784792., 2801568.,
      2818344., 2835120., 2789364., 2806176., 2822988., 2839800., 2793936.,
      2810784., 2827632., 2844480., 3571376., 3593312., 3615248., 3637184.,
      3577184., 3599168., 3621152., 3643136., 3582992., 3605024., 3627056.,
      3649088., 3588800., 3610880., 3632960., 3655040., 4410820., 4438240.,
      4465660., 4493080., 4417960., 4445440., 4472920., 4500400., 4425100.,
      4452640., 4480180., 4507720., 4432240., 4459840., 4487440., 4515040.,
      4439380., 4467040., 4494700., 4522360., 4446520., 4474240., 4501960.,
      4529680., 4453660., 4481440., 4509220., 4537000., 4460800., 4488640.,
      4516480., 4544320., 3506096., 3528224., 3550352., 3572480., 3511712.,
      3533888., 3556064., 3578240., 3517328., 3539552., 3561776., 3584000.,
      3522944., 3545216., 3567488., 3589760., 3528560., 3550880., 3573200.,
      3595520., 3534176., 3556544., 3578912., 3601280., 3539792., 3562208.,
      3584624., 3607040., 3545408., 3567872., 3590336., 3612800., 3803696.,
      3827552., 3851408., 3875264., 3809504., 3833408., 3857312., 3881216.,
      3815312., 3839264., 3863216., 3887168., 3821120., 3845120., 3869120.,
      3893120., 4696420., 4726240., 4756060., 4785880., 4703560., 4733440.,
      4763320., 4793200., 4710700., 4740640., 4770580., 4800520., 4717840.,
      4747840., 4777840., 4807840., 4724980., 4755040., 4785100., 4815160.,
      4732120., 4762240., 4792360., 4822480., 4739260., 4769440., 4799620.,
      4829800., 4746400., 4776640., 4806880., 4837120., 3730736., 3754784.,
      3778832., 3802880., 3736352., 3760448., 3784544., 3808640., 3741968.,
      3766112., 3790256., 3814400., 3747584., 3771776., 3795968., 3820160.,
      3753200., 3777440., 3801680., 3825920., 3758816., 3783104., 3807392.,
      3831680., 3764432., 3788768., 3813104., 3837440., 3770048., 3794432.,
      3818816., 3843200., 2640252., 2658144., 2676036., 2693928., 2644248.,
      2662176., 2680104., 2698032., 2648244., 2666208., 2684172., 2702136.,
      2652240., 2670240., 2688240., 2706240., 3256665., 3279030., 3301395.,
      3323760., 3261570., 3283980., 3306390., 3328800., 3266475., 3288930.,
      3311385., 3333840., 3271380., 3293880., 3316380., 3338880., 3276285.,
      3298830., 3321375., 3343920., 3281190., 3303780., 3326370., 3348960.,
      3286095., 3308730., 3331365., 3354000., 3291000., 3313680., 3336360.,
      3359040., 2584092., 2602128., 2620164., 2638200., 2587944., 2606016.,
      2624088., 2642160., 2591796., 2609904., 2628012., 2646120., 2595648.,
      2613792., 2631936., 2650080., 2599500., 2617680., 2635860., 2654040.,
      2603352., 2621568., 2639784., 2658000., 2607204., 2625456., 2643708.,
      2661960., 2611056., 2629344., 2647632., 2665920., 2800092., 2819424.,
      2838756., 2858088., 2804088., 2823456., 2842824., 2862192., 2808084.,
      2827488., 2846892., 2866296., 2812080., 2831520., 2850960., 2870400.,
      3452865., 3477030., 3501195., 3525360., 3457770., 3481980., 3506190.,
      3530400., 3462675., 3486930., 3511185., 3535440., 3467580., 3491880.,
      3516180., 3540480., 3472485., 3496830., 3521175., 3545520., 3477390.,
      3501780., 3526170., 3550560., 3482295., 3506730., 3531165., 3555600.,
      3487200., 3511680., 3536160., 3560640., 2738172., 2757648., 2777124.,
      2796600., 2742024., 2761536., 2781048., 2800560., 2745876., 2765424.,
      2784972., 2804520., 2749728., 2769312., 2788896., 2808480., 2753580.,
      2773200., 2792820., 2812440., 2757432., 2777088., 2796744., 2816400.,
      2761284., 2780976., 2800668., 2820360., 2765136., 2784864., 2804592.,
      2824320.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x8x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      329334., 335976., 342618., 349260., 329964., 336624., 343284., 349944.,
      330594., 337272., 343950., 350628., 331224., 337920., 344616., 351312.,
      331854., 338568., 345282., 351996., 332484., 339216., 345948., 352680.,
      333114., 339864., 346614., 353364., 333744., 340512., 347280., 354048.,
      334374., 341160., 347946., 354732., 335004., 341808., 348612., 355416.,
      335634., 342456., 349278., 356100., 336264., 343104., 349944., 356784.,
      336894., 343752., 350610., 357468., 337524., 344400., 351276., 358152.,
      338154., 345048., 351942., 358836., 338784., 345696., 352608., 359520.,
      339414., 346344., 353274., 360204., 340044., 346992., 353940., 360888.,
      340674., 347640., 354606., 361572., 341304., 348288., 355272., 362256.,
      354534., 361896., 369258., 376620., 355164., 362544., 369924., 377304.,
      355794., 363192., 370590., 377988., 356424., 363840., 371256., 378672.,
      357054., 364488., 371922., 379356., 357684., 365136., 372588., 380040.,
      358314., 365784., 373254., 380724., 358944., 366432., 373920., 381408.,
      359574., 367080., 374586., 382092., 360204., 367728., 375252., 382776.,
      360834., 368376., 375918., 383460., 361464., 369024., 376584., 384144.,
      362094., 369672., 377250., 384828., 362724., 370320., 377916., 385512.,
      363354., 370968., 378582., 386196., 363984., 371616., 379248., 386880.,
      364614., 372264., 379914., 387564., 365244., 372912., 380580., 388248.,
      365874., 373560., 381246., 388932., 366504., 374208., 381912., 389616.,
      379734., 387816., 395898., 403980., 380364., 388464., 396564., 404664.,
      380994., 389112., 397230., 405348., 381624., 389760., 397896., 406032.,
      382254., 390408., 398562., 406716., 382884., 391056., 399228., 407400.,
      383514., 391704., 399894., 408084., 384144., 392352., 400560., 408768.,
      384774., 393000., 401226., 409452., 385404., 393648., 401892., 410136.,
      386034., 394296., 402558., 410820., 386664., 394944., 403224., 411504.,
      387294., 395592., 403890., 412188., 387924., 396240., 404556., 412872.,
      388554., 396888., 405222., 413556., 389184., 397536., 405888., 414240.,
      389814., 398184., 406554., 414924., 390444., 398832., 407220., 415608.,
      391074., 399480., 407886., 416292., 391704., 400128., 408552., 416976.,
      404934., 413736., 422538., 431340., 405564., 414384., 423204., 432024.,
      406194., 415032., 423870., 432708., 406824., 415680., 424536., 433392.,
      407454., 416328., 425202., 434076., 408084., 416976., 425868., 434760.,
      408714., 417624., 426534., 435444., 409344., 418272., 427200., 436128.,
      409974., 418920., 427866., 436812., 410604., 419568., 428532., 437496.,
      411234., 420216., 429198., 438180., 411864., 420864., 429864., 438864.,
      412494., 421512., 430530., 439548., 413124., 422160., 431196., 440232.,
      413754., 422808., 431862., 440916., 414384., 423456., 432528., 441600.,
      415014., 424104., 433194., 442284., 415644., 424752., 433860., 442968.,
      416274., 425400., 434526., 443652., 416904., 426048., 435192., 444336.,
      430134., 439656., 449178., 458700., 430764., 440304., 449844., 459384.,
      431394., 440952., 450510., 460068., 432024., 441600., 451176., 460752.,
      432654., 442248., 451842., 461436., 433284., 442896., 452508., 462120.,
      433914., 443544., 453174., 462804., 434544., 444192., 453840., 463488.,
      435174., 444840., 454506., 464172., 435804., 445488., 455172., 464856.,
      436434., 446136., 455838., 465540., 437064., 446784., 456504., 466224.,
      437694., 447432., 457170., 466908., 438324., 448080., 457836., 467592.,
      438954., 448728., 458502., 468276., 439584., 449376., 459168., 468960.,
      440214., 450024., 459834., 469644., 440844., 450672., 460500., 470328.,
      441474., 451320., 461166., 471012., 442104., 451968., 461832., 471696.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      156156., 157344., 207400., 153672., 154824., 187995., 189390.,
      249530., 184800., 186150., 197760., 199155., 262340., 194250.,
      195600., 148920., 149964., 197392., 146040., 147048., 156228.,
      157272., 206968., 153096., 154104.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20091., 20262., 20433., 20604., 20775., 21288., 21459., 21630., 21801.,
      21972., 22485., 22656., 22827., 22998., 23169., 23682., 23853., 24024.,
      24195., 24366., 24879., 25050., 25221., 25392., 25563.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      308676., 312312., 311016., 314688., 409904., 414800., 303672., 307344.,
      305940., 309648., 371445., 375990., 374190., 378780., 492940., 499060.,
      365010., 369600., 367665., 372300., 390660., 395520., 393405., 398310.,
      518140., 524680., 383595., 388500., 386250., 391200., 293952., 297840.,
      296004., 299928., 389552., 394784., 288156., 292080., 290136., 294096.,
      308316., 312456., 310368., 314544., 408368., 413936., 302016., 306192.,
      303996., 308208.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38634., 40182., 38958., 40524., 39282., 40866., 39606., 41208., 39930.,
      41550., 40902., 42576., 41226., 42918., 41550., 43260., 41874., 43602.,
      42198., 43944., 43170., 44970., 43494., 45312., 43818., 45654., 44142.,
      45996., 44466., 46338., 45438., 47364., 45762., 47706., 46086., 48048.,
      46410., 48390., 46734., 48732., 47706., 49758., 48030., 50100., 48354.,
      50442., 48678., 50784., 49002., 51126.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      613716.,  617352.,  620988.,  624624., 618360., 622032., 625704.,
      629376.,  814912.,  819808.,  824704., 829600., 603672., 607344.,
      611016.,  614688.,  608172.,  611880., 615588., 619296., 738345.,
      742890.,  747435.,  751980.,  743790., 748380., 752970., 757560.,
      979760.,  985880.,  992000.,  998120., 725430., 730020., 734610.,
      739200.,  730695.,  735330.,  739965., 744600., 776460., 781320.,
      786180.,  791040.,  781905.,  786810., 791715., 796620., 1029740.,
      1036280., 1042820., 1049360., 762285., 767190., 772095., 777000.,
      767550.,  772500.,  777450.,  782400., 584016., 587904., 591792.,
      595680.,  588084.,  592008.,  595932., 599856., 773872., 779104.,
      784336.,  789568.,  572388.,  576312., 580236., 584160., 576312.,
      580272.,  584232.,  588192.,  612492., 616632., 620772., 624912.,
      616560.,  620736.,  624912.,  629088., 811168., 816736., 822304.,
      827872.,  599856.,  604032.,  608208., 612384., 603780., 607992.,
      612204.,  616416.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      75720., 77268., 78816.,  80364.,  76350., 77916., 79482., 81048.,
      76980., 78564., 80148.,  81732.,  77610., 79212., 80814., 82416.,
      78240., 79860., 81480.,  83100.,  80130., 81804., 83478., 85152.,
      80760., 82452., 84144.,  85836.,  81390., 83100., 84810., 86520.,
      82020., 83748., 85476.,  87204.,  82650., 84396., 86142., 87888.,
      84540., 86340., 88140.,  89940.,  85170., 86988., 88806., 90624.,
      85800., 87636., 89472.,  91308.,  86430., 88284., 90138., 91992.,
      87060., 88932., 90804.,  92676.,  88950., 90876., 92802., 94728.,
      89580., 91524., 93468.,  95412.,  90210., 92172., 94134., 96096.,
      90840., 92820., 94800.,  96780.,  91470., 93468., 95466., 97464.,
      93360., 95412., 97464.,  99516.,  93990., 96060., 98130., 100200.,
      94620., 96708., 98796.,  100884., 95250., 97356., 99462., 101568.,
      95880., 98004., 100128., 102252.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      311124., 312312., 313500., 314688., 413240., 414800., 306192., 307344.,
      308496., 309648., 374595., 375990., 377385., 378780., 497230., 499060.,
      368250., 369600., 370950., 372300., 394125., 395520., 396915., 398310.,
      522850., 524680., 387150., 388500., 389850., 391200., 296796., 297840.,
      298884., 299928., 393416., 394784., 291072., 292080., 293088., 294096.,
      311412., 312456., 313500., 314544., 412568., 413936., 305184., 306192.,
      307200., 308208.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      40011., 40182., 40353., 40524., 40695., 40866., 41037., 41208., 41379.,
      41550., 42405., 42576., 42747., 42918., 43089., 43260., 43431., 43602.,
      43773., 43944., 44799., 44970., 45141., 45312., 45483., 45654., 45825.,
      45996., 46167., 46338., 47193., 47364., 47535., 47706., 47877., 48048.,
      48219., 48390., 48561., 48732., 49587., 49758., 49929., 50100., 50271.,
      50442., 50613., 50784., 50955., 51126.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      615012.,  622248.,  617352.,  624624., 619692., 627000., 622032.,
      629376.,  816736.,  826480.,  819808., 829600., 605076., 612384.,
      607344.,  614688.,  609612.,  616992., 611880., 619296., 740145.,
      749190.,  742890.,  751980.,  745635., 754770., 748380., 757560.,
      982280.,  994460.,  985880.,  998120., 727365., 736500., 730020.,
      739200.,  732675.,  741900.,  735330., 744600., 778575., 788250.,
      781320.,  791040.,  784065.,  793830., 786810., 796620., 1032680.,
      1045700., 1036280., 1049360., 764535., 774300., 767190., 777000.,
      769845.,  779700.,  772500.,  782400., 585852., 593592., 587904.,
      595680.,  589956.,  597768.,  592008., 599856., 776416., 786832.,
      779104.,  789568.,  574332.,  582144., 576312., 584160., 578292.,
      586176.,  580272.,  588192.,  614580., 622824., 616632., 624912.,
      618684.,  627000.,  620736.,  629088., 814048., 825136., 816736.,
      827872.,  602052.,  610368.,  604032., 612384., 606012., 614400.,
      607992.,  616416.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76944., 80022.,  77268., 80364.,  77592., 80706.,  77916., 81048.,
      78240., 81390.,  78564., 81732.,  78888., 82074.,  79212., 82416.,
      79536., 82758.,  79860., 83100.,  81480., 84810.,  81804., 85152.,
      82128., 85494.,  82452., 85836.,  82776., 86178.,  83100., 86520.,
      83424., 86862.,  83748., 87204.,  84072., 87546.,  84396., 87888.,
      86016., 89598.,  86340., 89940.,  86664., 90282.,  86988., 90624.,
      87312., 90966.,  87636., 91308.,  87960., 91650.,  88284., 91992.,
      88608., 92334.,  88932., 92676.,  90552., 94386.,  90876., 94728.,
      91200., 95070.,  91524., 95412.,  91848., 95754.,  92172., 96096.,
      92496., 96438.,  92820., 96780.,  93144., 97122.,  93468., 97464.,
      95088., 99174.,  95412., 99516.,  95736., 99858.,  96060., 100200.,
      96384., 100542., 96708., 100884., 97032., 101226., 97356., 101568.,
      97680., 101910., 98004., 102252.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1222788., 1230024., 1237260., 1244496., 1227432., 1234704., 1241976.,
      1249248., 1232076., 1239384., 1246692., 1254000., 1236720., 1244064.,
      1251408., 1258752., 1623728., 1633472., 1643216., 1652960., 1629824.,
      1639616., 1649408., 1659200., 1202844., 1210152., 1217460., 1224768.,
      1207344., 1214688., 1222032., 1229376., 1211844., 1219224., 1226604.,
      1233984., 1216344., 1223760., 1231176., 1238592., 1471245., 1480290.,
      1489335., 1498380., 1476690., 1485780., 1494870., 1503960., 1482135.,
      1491270., 1500405., 1509540., 1487580., 1496760., 1505940., 1515120.,
      1952380., 1964560., 1976740., 1988920., 1959520., 1971760., 1984000.,
      1996240., 1445595., 1454730., 1463865., 1473000., 1450860., 1460040.,
      1469220., 1478400., 1456125., 1465350., 1474575., 1483800., 1461390.,
      1470660., 1479930., 1489200., 1547475., 1557150., 1566825., 1576500.,
      1552920., 1562640., 1572360., 1582080., 1558365., 1568130., 1577895.,
      1587660., 1563810., 1573620., 1583430., 1593240., 2052340., 2065360.,
      2078380., 2091400., 2059480., 2072560., 2085640., 2098720., 1519305.,
      1529070., 1538835., 1548600., 1524570., 1534380., 1544190., 1554000.,
      1529835., 1539690., 1549545., 1559400., 1535100., 1545000., 1554900.,
      1564800., 1163964., 1171704., 1179444., 1187184., 1168032., 1175808.,
      1183584., 1191360., 1172100., 1179912., 1187724., 1195536., 1176168.,
      1184016., 1191864., 1199712., 1542416., 1552832., 1563248., 1573664.,
      1547744., 1558208., 1568672., 1579136., 1140852., 1148664., 1156476.,
      1164288., 1144776., 1152624., 1160472., 1168320., 1148700., 1156584.,
      1164468., 1172352., 1152624., 1160544., 1168464., 1176384., 1220916.,
      1229160., 1237404., 1245648., 1224984., 1233264., 1241544., 1249824.,
      1229052., 1237368., 1245684., 1254000., 1233120., 1241472., 1249824.,
      1258176., 1617008., 1628096., 1639184., 1650272., 1622336., 1633472.,
      1644608., 1655744., 1195788., 1204104., 1212420., 1220736., 1199712.,
      1208064., 1216416., 1224768., 1203636., 1212024., 1220412., 1228800.,
      1207560., 1215984., 1224408., 1232832.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      150810., 153888., 156966., 160044., 151440., 154536., 157632., 160728.,
      152070., 155184., 158298., 161412., 152700., 155832., 158964., 162096.,
      153330., 156480., 159630., 162780., 153960., 157128., 160296., 163464.,
      154590., 157776., 160962., 164148., 155220., 158424., 161628., 164832.,
      155850., 159072., 162294., 165516., 156480., 159720., 162960., 166200.,
      159630., 162960., 166290., 169620., 160260., 163608., 166956., 170304.,
      160890., 164256., 167622., 170988., 161520., 164904., 168288., 171672.,
      162150., 165552., 168954., 172356., 162780., 166200., 169620., 173040.,
      163410., 166848., 170286., 173724., 164040., 167496., 170952., 174408.,
      164670., 168144., 171618., 175092., 165300., 168792., 172284., 175776.,
      168450., 172032., 175614., 179196., 169080., 172680., 176280., 179880.,
      169710., 173328., 176946., 180564., 170340., 173976., 177612., 181248.,
      170970., 174624., 178278., 181932., 171600., 175272., 178944., 182616.,
      172230., 175920., 179610., 183300., 172860., 176568., 180276., 183984.,
      173490., 177216., 180942., 184668., 174120., 177864., 181608., 185352.,
      177270., 181104., 184938., 188772., 177900., 181752., 185604., 189456.,
      178530., 182400., 186270., 190140., 179160., 183048., 186936., 190824.,
      179790., 183696., 187602., 191508., 180420., 184344., 188268., 192192.,
      181050., 184992., 188934., 192876., 181680., 185640., 189600., 193560.,
      182310., 186288., 190266., 194244., 182940., 186936., 190932., 194928.,
      186090., 190176., 194262., 198348., 186720., 190824., 194928., 199032.,
      187350., 191472., 195594., 199716., 187980., 192120., 196260., 200400.,
      188610., 192768., 196926., 201084., 189240., 193416., 197592., 201768.,
      189870., 194064., 198258., 202452., 190500., 194712., 198924., 203136.,
      191130., 195360., 199590., 203820., 191760., 196008., 200256., 204504.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      621060.,  622248.,  623436.,  624624., 625812., 627000., 628188.,
      629376.,  824920.,  826480.,  828040., 829600., 611232., 612384.,
      613536.,  614688.,  615840.,  616992., 618144., 619296., 747795.,
      749190.,  750585.,  751980.,  753375., 754770., 756165., 757560.,
      992630.,  994460.,  996290.,  998120., 735150., 736500., 737850.,
      739200.,  740550.,  741900.,  743250., 744600., 786855., 788250.,
      789645.,  791040.,  792435.,  793830., 795225., 796620., 1043870.,
      1045700., 1047530., 1049360., 772950., 774300., 775650., 777000.,
      778350.,  779700.,  781050.,  782400., 592548., 593592., 594636.,
      595680.,  596724.,  597768.,  598812., 599856., 785464., 786832.,
      788200.,  789568.,  581136.,  582144., 583152., 584160., 585168.,
      586176.,  587184.,  588192.,  621780., 622824., 623868., 624912.,
      625956.,  627000.,  628044.,  629088., 823768., 825136., 826504.,
      827872.,  609360.,  610368.,  611376., 612384., 613392., 614400.,
      615408.,  616416.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      79851.,  80022.,  80193.,  80364.,  80535.,  80706.,  80877.,  81048.,
      81219.,  81390.,  81561.,  81732.,  81903.,  82074.,  82245.,  82416.,
      82587.,  82758.,  82929.,  83100.,  84639.,  84810.,  84981.,  85152.,
      85323.,  85494.,  85665.,  85836.,  86007.,  86178.,  86349.,  86520.,
      86691.,  86862.,  87033.,  87204.,  87375.,  87546.,  87717.,  87888.,
      89427.,  89598.,  89769.,  89940.,  90111.,  90282.,  90453.,  90624.,
      90795.,  90966.,  91137.,  91308.,  91479.,  91650.,  91821.,  91992.,
      92163.,  92334.,  92505.,  92676.,  94215.,  94386.,  94557.,  94728.,
      94899.,  95070.,  95241.,  95412.,  95583.,  95754.,  95925.,  96096.,
      96267.,  96438.,  96609.,  96780.,  96951.,  97122.,  97293.,  97464.,
      99003.,  99174.,  99345.,  99516.,  99687.,  99858.,  100029., 100200.,
      100371., 100542., 100713., 100884., 101055., 101226., 101397., 101568.,
      101739., 101910., 102081., 102252.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1227684., 1242120., 1230024., 1244496., 1232364., 1246872., 1234704.,
      1249248., 1237044., 1251624., 1239384., 1254000., 1241724., 1256376.,
      1244064., 1258752., 1630400., 1649840., 1633472., 1652960., 1636544.,
      1656080., 1639616., 1659200., 1207884., 1222464., 1210152., 1224768.,
      1212420., 1227072., 1214688., 1229376., 1216956., 1231680., 1219224.,
      1233984., 1221492., 1236288., 1223760., 1238592., 1477545., 1495590.,
      1480290., 1498380., 1483035., 1501170., 1485780., 1503960., 1488525.,
      1506750., 1491270., 1509540., 1494015., 1512330., 1496760., 1515120.,
      1960960., 1985260., 1964560., 1988920., 1968160., 1992580., 1971760.,
      1996240., 1452075., 1470300., 1454730., 1473000., 1457385., 1475700.,
      1460040., 1478400., 1462695., 1481100., 1465350., 1483800., 1468005.,
      1486500., 1470660., 1489200., 1554405., 1573710., 1557150., 1576500.,
      1559895., 1579290., 1562640., 1582080., 1565385., 1584870., 1568130.,
      1587660., 1570875., 1590450., 1573620., 1593240., 2061760., 2087740.,
      2065360., 2091400., 2068960., 2095060., 2072560., 2098720., 1526415.,
      1545900., 1529070., 1548600., 1531725., 1551300., 1534380., 1554000.,
      1537035., 1556700., 1539690., 1559400., 1542345., 1562100., 1545000.,
      1564800., 1169652., 1185096., 1171704., 1187184., 1173756., 1189272.,
      1175808., 1191360., 1177860., 1193448., 1179912., 1195536., 1181964.,
      1197624., 1184016., 1199712., 1550144., 1570928., 1552832., 1573664.,
      1555520., 1576400., 1558208., 1579136., 1146684., 1162272., 1148664.,
      1164288., 1150644., 1166304., 1152624., 1168320., 1154604., 1170336.,
      1156584., 1172352., 1158564., 1174368., 1160544., 1176384., 1227108.,
      1243560., 1229160., 1245648., 1231212., 1247736., 1233264., 1249824.,
      1235316., 1251912., 1237368., 1254000., 1239420., 1256088., 1241472.,
      1258176., 1625408., 1647536., 1628096., 1650272., 1630784., 1653008.,
      1633472., 1655744., 1202124., 1218720., 1204104., 1220736., 1206084.,
      1222752., 1208064., 1224768., 1210044., 1226784., 1212024., 1228800.,
      1214004., 1230816., 1215984., 1232832.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      153564., 159702., 153888., 160044., 154212., 160386., 154536., 160728.,
      154860., 161070., 155184., 161412., 155508., 161754., 155832., 162096.,
      156156., 162438., 156480., 162780., 156804., 163122., 157128., 163464.,
      157452., 163806., 157776., 164148., 158100., 164490., 158424., 164832.,
      158748., 165174., 159072., 165516., 159396., 165858., 159720., 166200.,
      162636., 169278., 162960., 169620., 163284., 169962., 163608., 170304.,
      163932., 170646., 164256., 170988., 164580., 171330., 164904., 171672.,
      165228., 172014., 165552., 172356., 165876., 172698., 166200., 173040.,
      166524., 173382., 166848., 173724., 167172., 174066., 167496., 174408.,
      167820., 174750., 168144., 175092., 168468., 175434., 168792., 175776.,
      171708., 178854., 172032., 179196., 172356., 179538., 172680., 179880.,
      173004., 180222., 173328., 180564., 173652., 180906., 173976., 181248.,
      174300., 181590., 174624., 181932., 174948., 182274., 175272., 182616.,
      175596., 182958., 175920., 183300., 176244., 183642., 176568., 183984.,
      176892., 184326., 177216., 184668., 177540., 185010., 177864., 185352.,
      180780., 188430., 181104., 188772., 181428., 189114., 181752., 189456.,
      182076., 189798., 182400., 190140., 182724., 190482., 183048., 190824.,
      183372., 191166., 183696., 191508., 184020., 191850., 184344., 192192.,
      184668., 192534., 184992., 192876., 185316., 193218., 185640., 193560.,
      185964., 193902., 186288., 194244., 186612., 194586., 186936., 194928.,
      189852., 198006., 190176., 198348., 190500., 198690., 190824., 199032.,
      191148., 199374., 191472., 199716., 191796., 200058., 192120., 200400.,
      192444., 200742., 192768., 201084., 193092., 201426., 193416., 201768.,
      193740., 202110., 194064., 202452., 194388., 202794., 194712., 203136.,
      195036., 203478., 195360., 203820., 195684., 204162., 196008., 204504.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2440932., 2455368., 2469804., 2484240., 2445576., 2460048., 2474520.,
      2488992., 2450220., 2464728., 2479236., 2493744., 2454864., 2469408.,
      2483952., 2498496., 2459508., 2474088., 2488668., 2503248., 2464152.,
      2478768., 2493384., 2508000., 2468796., 2483448., 2498100., 2512752.,
      2473440., 2488128., 2502816., 2517504., 3241360., 3260800., 3280240.,
      3299680., 3247456., 3266944., 3286432., 3305920., 3253552., 3273088.,
      3292624., 3312160., 3259648., 3279232., 3298816., 3318400., 2401188.,
      2415768., 2430348., 2444928., 2405688., 2420304., 2434920., 2449536.,
      2410188., 2424840., 2439492., 2454144., 2414688., 2429376., 2444064.,
      2458752., 2419188., 2433912., 2448636., 2463360., 2423688., 2438448.,
      2453208., 2467968., 2428188., 2442984., 2457780., 2472576., 2432688.,
      2447520., 2462352., 2477184., 2937045., 2955090., 2973135., 2991180.,
      2942490., 2960580., 2978670., 2996760., 2947935., 2966070., 2984205.,
      3002340., 2953380., 2971560., 2989740., 3007920., 2958825., 2977050.,
      2995275., 3013500., 2964270., 2982540., 3000810., 3019080., 2969715.,
      2988030., 3006345., 3024660., 2975160., 2993520., 3011880., 3030240.,
      3897620., 3921920., 3946220., 3970520., 3904760., 3929120., 3953480.,
      3977840., 3911900., 3936320., 3960740., 3985160., 3919040., 3943520.,
      3968000., 3992480., 2885925., 2904150., 2922375., 2940600., 2891190.,
      2909460., 2927730., 2946000., 2896455., 2914770., 2933085., 2951400.,
      2901720., 2920080., 2938440., 2956800., 2906985., 2925390., 2943795.,
      2962200., 2912250., 2930700., 2949150., 2967600., 2917515., 2936010.,
      2954505., 2973000., 2922780., 2941320., 2959860., 2978400., 3089505.,
      3108810., 3128115., 3147420., 3094950., 3114300., 3133650., 3153000.,
      3100395., 3119790., 3139185., 3158580., 3105840., 3125280., 3144720.,
      3164160., 3111285., 3130770., 3150255., 3169740., 3116730., 3136260.,
      3155790., 3175320., 3122175., 3141750., 3161325., 3180900., 3127620.,
      3147240., 3166860., 3186480., 4097540., 4123520., 4149500., 4175480.,
      4104680., 4130720., 4156760., 4182800., 4111820., 4137920., 4164020.,
      4190120., 4118960., 4145120., 4171280., 4197440., 3033345., 3052830.,
      3072315., 3091800., 3038610., 3058140., 3077670., 3097200., 3043875.,
      3063450., 3083025., 3102600., 3049140., 3068760., 3088380., 3108000.,
      3054405., 3074070., 3093735., 3113400., 3059670., 3079380., 3099090.,
      3118800., 3064935., 3084690., 3104445., 3124200., 3070200., 3090000.,
      3109800., 3129600., 2323860., 2339304., 2354748., 2370192., 2327928.,
      2343408., 2358888., 2374368., 2331996., 2347512., 2363028., 2378544.,
      2336064., 2351616., 2367168., 2382720., 2340132., 2355720., 2371308.,
      2386896., 2344200., 2359824., 2375448., 2391072., 2348268., 2363928.,
      2379588., 2395248., 2352336., 2368032., 2383728., 2399424., 3079504.,
      3100288., 3121072., 3141856., 3084832., 3105664., 3126496., 3147328.,
      3090160., 3111040., 3131920., 3152800., 3095488., 3116416., 3137344.,
      3158272., 2277780., 2293368., 2308956., 2324544., 2281704., 2297328.,
      2312952., 2328576., 2285628., 2301288., 2316948., 2332608., 2289552.,
      2305248., 2320944., 2336640., 2293476., 2309208., 2324940., 2340672.,
      2297400., 2313168., 2328936., 2344704., 2301324., 2317128., 2332932.,
      2348736., 2305248., 2321088., 2336928., 2352768., 2437764., 2454216.,
      2470668., 2487120., 2441832., 2458320., 2474808., 2491296., 2445900.,
      2462424., 2478948., 2495472., 2449968., 2466528., 2483088., 2499648.,
      2454036., 2470632., 2487228., 2503824., 2458104., 2474736., 2491368.,
      2508000., 2462172., 2478840., 2495508., 2512176., 2466240., 2482944.,
      2499648., 2516352., 3228688., 3250816., 3272944., 3295072., 3234016.,
      3256192., 3278368., 3300544., 3239344., 3261568., 3283792., 3306016.,
      3244672., 3266944., 3289216., 3311488., 2387652., 2404248., 2420844.,
      2437440., 2391576., 2408208., 2424840., 2441472., 2395500., 2412168.,
      2428836., 2445504., 2399424., 2416128., 2432832., 2449536., 2403348.,
      2420088., 2436828., 2453568., 2407272., 2424048., 2440824., 2457600.,
      2411196., 2428008., 2444820., 2461632., 2415120., 2431968., 2448816.,
      2465664.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      300990., 307128., 313266., 319404., 301620., 307776., 313932., 320088.,
      302250., 308424., 314598., 320772., 302880., 309072., 315264., 321456.,
      303510., 309720., 315930., 322140., 304140., 310368., 316596., 322824.,
      304770., 311016., 317262., 323508., 305400., 311664., 317928., 324192.,
      306030., 312312., 318594., 324876., 306660., 312960., 319260., 325560.,
      307290., 313608., 319926., 326244., 307920., 314256., 320592., 326928.,
      308550., 314904., 321258., 327612., 309180., 315552., 321924., 328296.,
      309810., 316200., 322590., 328980., 310440., 316848., 323256., 329664.,
      311070., 317496., 323922., 330348., 311700., 318144., 324588., 331032.,
      312330., 318792., 325254., 331716., 312960., 319440., 325920., 332400.,
      318630., 325272., 331914., 338556., 319260., 325920., 332580., 339240.,
      319890., 326568., 333246., 339924., 320520., 327216., 333912., 340608.,
      321150., 327864., 334578., 341292., 321780., 328512., 335244., 341976.,
      322410., 329160., 335910., 342660., 323040., 329808., 336576., 343344.,
      323670., 330456., 337242., 344028., 324300., 331104., 337908., 344712.,
      324930., 331752., 338574., 345396., 325560., 332400., 339240., 346080.,
      326190., 333048., 339906., 346764., 326820., 333696., 340572., 347448.,
      327450., 334344., 341238., 348132., 328080., 334992., 341904., 348816.,
      328710., 335640., 342570., 349500., 329340., 336288., 343236., 350184.,
      329970., 336936., 343902., 350868., 330600., 337584., 344568., 351552.,
      336270., 343416., 350562., 357708., 336900., 344064., 351228., 358392.,
      337530., 344712., 351894., 359076., 338160., 345360., 352560., 359760.,
      338790., 346008., 353226., 360444., 339420., 346656., 353892., 361128.,
      340050., 347304., 354558., 361812., 340680., 347952., 355224., 362496.,
      341310., 348600., 355890., 363180., 341940., 349248., 356556., 363864.,
      342570., 349896., 357222., 364548., 343200., 350544., 357888., 365232.,
      343830., 351192., 358554., 365916., 344460., 351840., 359220., 366600.,
      345090., 352488., 359886., 367284., 345720., 353136., 360552., 367968.,
      346350., 353784., 361218., 368652., 346980., 354432., 361884., 369336.,
      347610., 355080., 362550., 370020., 348240., 355728., 363216., 370704.,
      353910., 361560., 369210., 376860., 354540., 362208., 369876., 377544.,
      355170., 362856., 370542., 378228., 355800., 363504., 371208., 378912.,
      356430., 364152., 371874., 379596., 357060., 364800., 372540., 380280.,
      357690., 365448., 373206., 380964., 358320., 366096., 373872., 381648.,
      358950., 366744., 374538., 382332., 359580., 367392., 375204., 383016.,
      360210., 368040., 375870., 383700., 360840., 368688., 376536., 384384.,
      361470., 369336., 377202., 385068., 362100., 369984., 377868., 385752.,
      362730., 370632., 378534., 386436., 363360., 371280., 379200., 387120.,
      363990., 371928., 379866., 387804., 364620., 372576., 380532., 388488.,
      365250., 373224., 381198., 389172., 365880., 373872., 381864., 389856.,
      371550., 379704., 387858., 396012., 372180., 380352., 388524., 396696.,
      372810., 381000., 389190., 397380., 373440., 381648., 389856., 398064.,
      374070., 382296., 390522., 398748., 374700., 382944., 391188., 399432.,
      375330., 383592., 391854., 400116., 375960., 384240., 392520., 400800.,
      376590., 384888., 393186., 401484., 377220., 385536., 393852., 402168.,
      377850., 386184., 394518., 402852., 378480., 386832., 395184., 403536.,
      379110., 387480., 395850., 404220., 379740., 388128., 396516., 404904.,
      380370., 388776., 397182., 405588., 381000., 389424., 397848., 406272.,
      381630., 390072., 398514., 406956., 382260., 390720., 399180., 407640.,
      382890., 391368., 399846., 408324., 383520., 392016., 400512., 409008.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      179136., 236120., 237680., 176112., 177264., 215640., 284110.,
      285940., 211770., 213120., 226800., 298750., 300580., 222570.,
      223920., 170784., 224792., 226160., 167328., 168336., 179136.,
      235736., 237104., 175392., 176400.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22911., 23082., 23253., 23424., 23595., 24279., 24450., 24621., 24792.,
      24963., 25647., 25818., 25989., 26160., 26331., 27015., 27186., 27357.,
      27528., 27699., 28383., 28554., 28725., 28896., 29067.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      354096., 358272., 466672., 472240., 469744., 475360., 348012., 352224.,
      350280., 354528., 426060., 431280., 561260., 568220., 564860., 571880.,
      418275., 423540., 420930., 426240., 448020., 453600., 590060., 597500.,
      593660., 601160., 439515., 445140., 442170., 447840., 337104., 341568.,
      443632., 449584., 446320., 452320., 330156., 334656., 332136., 336672.,
      353520., 358272., 465136., 471472., 467824., 474208., 345996., 350784.,
      347976., 352800.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44058., 45822., 44382., 46164., 44706., 46506., 45030., 46848., 45354.,
      47190., 46650., 48558., 46974., 48900., 47298., 49242., 47622., 49584.,
      47946., 49926., 49242., 51294., 49566., 51636., 49890., 51978., 50214.,
      52320., 50538., 52662., 51834., 54030., 52158., 54372., 52482., 54714.,
      52806., 55056., 53130., 55398., 54426., 56766., 54750., 57108., 55074.,
      57450., 55398., 57792., 55722., 58134.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      704016.,  708192.,  712368.,  716544.,  927776.,  933344.,  938912.,
      944480.,  933872.,  939488.,  945104.,  950720.,  691812.,  696024.,
      700236.,  704448.,  696312.,  700560.,  704808.,  709056.,  846900.,
      852120.,  857340.,  862560.,  1115560., 1122520., 1129480., 1136440.,
      1122700., 1129720., 1136740., 1143760., 831285.,  836550.,  841815.,
      847080.,  836550.,  841860.,  847170.,  852480.,  890460.,  896040.,
      901620.,  907200.,  1172680., 1180120., 1187560., 1195000., 1179820.,
      1187320., 1194820., 1202320., 873405.,  879030.,  884655.,  890280.,
      878670.,  884340.,  890010.,  895680.,  669744.,  674208.,  678672.,
      683136.,  881312.,  887264.,  893216.,  899168.,  886640.,  892640.,
      898640.,  904640.,  655812.,  660312.,  664812.,  669312.,  659736.,
      664272.,  668808.,  673344.,  702288.,  707040.,  711792.,  716544.,
      923936.,  930272.,  936608.,  942944.,  929264.,  935648.,  942032.,
      948416.,  687204.,  691992.,  696780.,  701568.,  691128.,  695952.,
      700776.,  705600.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86352.,  88116.,  89880.,  91644.,  86982.,  88764.,  90546.,  92328.,
      87612.,  89412.,  91212.,  93012.,  88242.,  90060.,  91878.,  93696.,
      88872.,  90708.,  92544.,  94380.,  91392.,  93300.,  95208.,  97116.,
      92022.,  93948.,  95874.,  97800.,  92652.,  94596.,  96540.,  98484.,
      93282.,  95244.,  97206.,  99168.,  93912.,  95892.,  97872.,  99852.,
      96432.,  98484.,  100536., 102588., 97062.,  99132.,  101202., 103272.,
      97692.,  99780.,  101868., 103956., 98322.,  100428., 102534., 104640.,
      98952.,  101076., 103200., 105324., 101472., 103668., 105864., 108060.,
      102102., 104316., 106530., 108744., 102732., 104964., 107196., 109428.,
      103362., 105612., 107862., 110112., 103992., 106260., 108528., 110796.,
      106512., 108852., 111192., 113532., 107142., 109500., 111858., 114216.,
      107772., 110148., 112524., 114900., 108402., 110796., 113190., 115584.,
      109032., 111444., 113856., 116268.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      357084., 358272., 470680., 472240., 473800., 475360., 351072., 352224.,
      353376., 354528., 429885., 431280., 566390., 568220., 570050., 571880.,
      422190., 423540., 424890., 426240., 452205., 453600., 595670., 597500.,
      599330., 601160., 443790., 445140., 446490., 447840., 340524., 341568.,
      448216., 449584., 450952., 452320., 333648., 334656., 335664., 336672.,
      357228., 358272., 470104., 471472., 472840., 474208., 349776., 350784.,
      351792., 352800.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45651., 45822., 45993., 46164., 46335., 46506., 46677., 46848., 47019.,
      47190., 48387., 48558., 48729., 48900., 49071., 49242., 49413., 49584.,
      49755., 49926., 51123., 51294., 51465., 51636., 51807., 51978., 52149.,
      52320., 52491., 52662., 53859., 54030., 54201., 54372., 54543., 54714.,
      54885., 55056., 55227., 55398., 56595., 56766., 56937., 57108., 57279.,
      57450., 57621., 57792., 57963., 58134.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      705852.,  714168.,  708192.,  716544.,  930272.,  941360.,  933344.,
      944480.,  936416.,  947600.,  939488.,  950720.,  693756.,  702144.,
      696024.,  704448.,  698292.,  706752.,  700560.,  709056.,  849375.,
      859770.,  852120.,  862560.,  1118920., 1132780., 1122520., 1136440.,
      1126120., 1140100., 1129720., 1143760., 833895.,  844380.,  836550.,
      847080.,  839205.,  849780.,  841860.,  852480.,  893295.,  904410.,
      896040.,  907200.,  1176520., 1191340., 1180120., 1195000., 1183720.,
      1198660., 1187320., 1202320., 876375.,  887580.,  879030.,  890280.,
      881685.,  892980.,  884340.,  895680.,  672156.,  681048.,  674208.,
      683136.,  884576.,  896432.,  887264.,  899168.,  889952.,  901904.,
      892640.,  904640.,  658332.,  667296.,  660312.,  669312.,  662292.,
      671328.,  664272.,  673344.,  704988.,  714456.,  707040.,  716544.,
      927584.,  940208.,  930272.,  942944.,  932960.,  945680.,  935648.,
      948416.,  690012.,  699552.,  691992.,  701568.,  693972.,  703584.,
      695952.,  705600.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      87792.,  91302.,  88116.,  91644.,  88440.,  91986.,  88764.,  92328.,
      89088.,  92670.,  89412.,  93012.,  89736.,  93354.,  90060.,  93696.,
      90384.,  94038.,  90708.,  94380.,  92976.,  96774.,  93300.,  97116.,
      93624.,  97458.,  93948.,  97800.,  94272.,  98142.,  94596.,  98484.,
      94920.,  98826.,  95244.,  99168.,  95568.,  99510.,  95892.,  99852.,
      98160.,  102246., 98484.,  102588., 98808.,  102930., 99132.,  103272.,
      99456.,  103614., 99780.,  103956., 100104., 104298., 100428., 104640.,
      100752., 104982., 101076., 105324., 103344., 107718., 103668., 108060.,
      103992., 108402., 104316., 108744., 104640., 109086., 104964., 109428.,
      105288., 109770., 105612., 110112., 105936., 110454., 106260., 110796.,
      108528., 113190., 108852., 113532., 109176., 113874., 109500., 114216.,
      109824., 114558., 110148., 114900., 110472., 115242., 110796., 115584.,
      111120., 115926., 111444., 116268.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1403388., 1411704., 1420020., 1428336., 1408032., 1416384., 1424736.,
      1433088., 1849456., 1860544., 1871632., 1882720., 1855552., 1866688.,
      1877824., 1888960., 1861648., 1872832., 1884016., 1895200., 1867744.,
      1878976., 1890208., 1901440., 1379124., 1387512., 1395900., 1404288.,
      1383624., 1392048., 1400472., 1408896., 1388124., 1396584., 1405044.,
      1413504., 1392624., 1401120., 1409616., 1418112., 1688355., 1698750.,
      1709145., 1719540., 1693800., 1704240., 1714680., 1725120., 2223980.,
      2237840., 2251700., 2265560., 2231120., 2245040., 2258960., 2272880.,
      2238260., 2252240., 2266220., 2280200., 2245400., 2259440., 2273480.,
      2287520., 1657305., 1667790., 1678275., 1688760., 1662570., 1673100.,
      1683630., 1694160., 1667835., 1678410., 1688985., 1699560., 1673100.,
      1683720., 1694340., 1704960., 1775475., 1786590., 1797705., 1808820.,
      1780920., 1792080., 1803240., 1814400., 2338220., 2353040., 2367860.,
      2382680., 2345360., 2360240., 2375120., 2390000., 2352500., 2367440.,
      2382380., 2397320., 2359640., 2374640., 2389640., 2404640., 1741545.,
      1752750., 1763955., 1775160., 1746810., 1758060., 1769310., 1780560.,
      1752075., 1763370., 1774665., 1785960., 1757340., 1768680., 1780020.,
      1791360., 1335420., 1344312., 1353204., 1362096., 1339488., 1348416.,
      1357344., 1366272., 1757296., 1769152., 1781008., 1792864., 1762624.,
      1774528., 1786432., 1798336., 1767952., 1779904., 1791856., 1803808.,
      1773280., 1785280., 1797280., 1809280., 1307700., 1316664., 1325628.,
      1334592., 1311624., 1320624., 1329624., 1338624., 1315548., 1324584.,
      1333620., 1342656., 1319472., 1328544., 1337616., 1346688., 1400508.,
      1409976., 1419444., 1428912., 1404576., 1414080., 1423584., 1433088.,
      1842544., 1855168., 1867792., 1880416., 1847872., 1860544., 1873216.,
      1885888., 1853200., 1865920., 1878640., 1891360., 1858528., 1871296.,
      1884064., 1896832., 1370484., 1380024., 1389564., 1399104., 1374408.,
      1383984., 1393560., 1403136., 1378332., 1387944., 1397556., 1407168.,
      1382256., 1391904., 1401552., 1411200.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      172074., 175584., 179094., 182604., 172704., 176232., 179760., 183288.,
      173334., 176880., 180426., 183972., 173964., 177528., 181092., 184656.,
      174594., 178176., 181758., 185340., 175224., 178824., 182424., 186024.,
      175854., 179472., 183090., 186708., 176484., 180120., 183756., 187392.,
      177114., 180768., 184422., 188076., 177744., 181416., 185088., 188760.,
      182154., 185952., 189750., 193548., 182784., 186600., 190416., 194232.,
      183414., 187248., 191082., 194916., 184044., 187896., 191748., 195600.,
      184674., 188544., 192414., 196284., 185304., 189192., 193080., 196968.,
      185934., 189840., 193746., 197652., 186564., 190488., 194412., 198336.,
      187194., 191136., 195078., 199020., 187824., 191784., 195744., 199704.,
      192234., 196320., 200406., 204492., 192864., 196968., 201072., 205176.,
      193494., 197616., 201738., 205860., 194124., 198264., 202404., 206544.,
      194754., 198912., 203070., 207228., 195384., 199560., 203736., 207912.,
      196014., 200208., 204402., 208596., 196644., 200856., 205068., 209280.,
      197274., 201504., 205734., 209964., 197904., 202152., 206400., 210648.,
      202314., 206688., 211062., 215436., 202944., 207336., 211728., 216120.,
      203574., 207984., 212394., 216804., 204204., 208632., 213060., 217488.,
      204834., 209280., 213726., 218172., 205464., 209928., 214392., 218856.,
      206094., 210576., 215058., 219540., 206724., 211224., 215724., 220224.,
      207354., 211872., 216390., 220908., 207984., 212520., 217056., 221592.,
      212394., 217056., 221718., 226380., 213024., 217704., 222384., 227064.,
      213654., 218352., 223050., 227748., 214284., 219000., 223716., 228432.,
      214914., 219648., 224382., 229116., 215544., 220296., 225048., 229800.,
      216174., 220944., 225714., 230484., 216804., 221592., 226380., 231168.,
      217434., 222240., 227046., 231852., 218064., 222888., 227712., 232536.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      712980.,  714168.,  715356.,  716544.,  939800.,  941360.,  942920.,
      944480.,  946040.,  947600.,  949160.,  950720.,  700992.,  702144.,
      703296.,  704448.,  705600.,  706752.,  707904.,  709056.,  858375.,
      859770.,  861165.,  862560.,  1130950., 1132780., 1134610., 1136440.,
      1138270., 1140100., 1141930., 1143760., 843030.,  844380.,  845730.,
      847080.,  848430.,  849780.,  851130.,  852480.,  903015.,  904410.,
      905805.,  907200.,  1189510., 1191340., 1193170., 1195000., 1196830.,
      1198660., 1200490., 1202320., 886230.,  887580.,  888930.,  890280.,
      891630.,  892980.,  894330.,  895680.,  680004.,  681048.,  682092.,
      683136.,  895064.,  896432.,  897800.,  899168.,  900536.,  901904.,
      903272.,  904640.,  666288.,  667296.,  668304.,  669312.,  670320.,
      671328.,  672336.,  673344.,  713412.,  714456.,  715500.,  716544.,
      938840.,  940208.,  941576.,  942944.,  944312.,  945680.,  947048.,
      948416.,  698544.,  699552.,  700560.,  701568.,  702576.,  703584.,
      704592.,  705600.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91131.,  91302.,  91473.,  91644.,  91815.,  91986.,  92157.,  92328.,
      92499.,  92670.,  92841.,  93012.,  93183.,  93354.,  93525.,  93696.,
      93867.,  94038.,  94209.,  94380.,  96603.,  96774.,  96945.,  97116.,
      97287.,  97458.,  97629.,  97800.,  97971.,  98142.,  98313.,  98484.,
      98655.,  98826.,  98997.,  99168.,  99339.,  99510.,  99681.,  99852.,
      102075., 102246., 102417., 102588., 102759., 102930., 103101., 103272.,
      103443., 103614., 103785., 103956., 104127., 104298., 104469., 104640.,
      104811., 104982., 105153., 105324., 107547., 107718., 107889., 108060.,
      108231., 108402., 108573., 108744., 108915., 109086., 109257., 109428.,
      109599., 109770., 109941., 110112., 110283., 110454., 110625., 110796.,
      113019., 113190., 113361., 113532., 113703., 113874., 114045., 114216.,
      114387., 114558., 114729., 114900., 115071., 115242., 115413., 115584.,
      115755., 115926., 116097., 116268.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1409364., 1425960., 1411704., 1428336., 1414044., 1430712., 1416384.,
      1433088., 1857472., 1879600., 1860544., 1882720., 1863616., 1885840.,
      1866688., 1888960., 1869760., 1892080., 1872832., 1895200., 1875904.,
      1898320., 1878976., 1901440., 1385244., 1401984., 1387512., 1404288.,
      1389780., 1406592., 1392048., 1408896., 1394316., 1411200., 1396584.,
      1413504., 1398852., 1415808., 1401120., 1418112., 1696005., 1716750.,
      1698750., 1719540., 1701495., 1722330., 1704240., 1725120., 2234240.,
      2261900., 2237840., 2265560., 2241440., 2269220., 2245040., 2272880.,
      2248640., 2276540., 2252240., 2280200., 2255840., 2283860., 2259440.,
      2287520., 1665135., 1686060., 1667790., 1688760., 1670445., 1691460.,
      1673100., 1694160., 1675755., 1696860., 1678410., 1699560., 1681065.,
      1702260., 1683720., 1704960., 1783845., 1806030., 1786590., 1808820.,
      1789335., 1811610., 1792080., 1814400., 2349440., 2379020., 2353040.,
      2382680., 2356640., 2386340., 2360240., 2390000., 2363840., 2393660.,
      2367440., 2397320., 2371040., 2400980., 2374640., 2404640., 1750095.,
      1772460., 1752750., 1775160., 1755405., 1777860., 1758060., 1780560.,
      1760715., 1783260., 1763370., 1785960., 1766025., 1788660., 1768680.,
      1791360., 1342260., 1360008., 1344312., 1362096., 1346364., 1364184.,
      1348416., 1366272., 1766464., 1790128., 1769152., 1792864., 1771840.,
      1795600., 1774528., 1798336., 1777216., 1801072., 1779904., 1803808.,
      1782592., 1806544., 1785280., 1809280., 1314684., 1332576., 1316664.,
      1334592., 1318644., 1336608., 1320624., 1338624., 1322604., 1340640.,
      1324584., 1342656., 1326564., 1344672., 1328544., 1346688., 1407924.,
      1426824., 1409976., 1428912., 1412028., 1431000., 1414080., 1433088.,
      1852480., 1877680., 1855168., 1880416., 1857856., 1883152., 1860544.,
      1885888., 1863232., 1888624., 1865920., 1891360., 1868608., 1894096.,
      1871296., 1896832., 1378044., 1397088., 1380024., 1399104., 1382004.,
      1401120., 1383984., 1403136., 1385964., 1405152., 1387944., 1407168.,
      1389924., 1409184., 1391904., 1411200.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      175260., 182262., 175584., 182604., 175908., 182946., 176232., 183288.,
      176556., 183630., 176880., 183972., 177204., 184314., 177528., 184656.,
      177852., 184998., 178176., 185340., 178500., 185682., 178824., 186024.,
      179148., 186366., 179472., 186708., 179796., 187050., 180120., 187392.,
      180444., 187734., 180768., 188076., 181092., 188418., 181416., 188760.,
      185628., 193206., 185952., 193548., 186276., 193890., 186600., 194232.,
      186924., 194574., 187248., 194916., 187572., 195258., 187896., 195600.,
      188220., 195942., 188544., 196284., 188868., 196626., 189192., 196968.,
      189516., 197310., 189840., 197652., 190164., 197994., 190488., 198336.,
      190812., 198678., 191136., 199020., 191460., 199362., 191784., 199704.,
      195996., 204150., 196320., 204492., 196644., 204834., 196968., 205176.,
      197292., 205518., 197616., 205860., 197940., 206202., 198264., 206544.,
      198588., 206886., 198912., 207228., 199236., 207570., 199560., 207912.,
      199884., 208254., 200208., 208596., 200532., 208938., 200856., 209280.,
      201180., 209622., 201504., 209964., 201828., 210306., 202152., 210648.,
      206364., 215094., 206688., 215436., 207012., 215778., 207336., 216120.,
      207660., 216462., 207984., 216804., 208308., 217146., 208632., 217488.,
      208956., 217830., 209280., 218172., 209604., 218514., 209928., 218856.,
      210252., 219198., 210576., 219540., 210900., 219882., 211224., 220224.,
      211548., 220566., 211872., 220908., 212196., 221250., 212520., 221592.,
      216732., 226038., 217056., 226380., 217380., 226722., 217704., 227064.,
      218028., 227406., 218352., 227748., 218676., 228090., 219000., 228432.,
      219324., 228774., 219648., 229116., 219972., 229458., 220296., 229800.,
      220620., 230142., 220944., 230484., 221268., 230826., 221592., 231168.,
      221916., 231510., 222240., 231852., 222564., 232194., 222888., 232536.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2802132., 2818728., 2835324., 2851920., 2806776., 2823408., 2840040.,
      2856672., 2811420., 2828088., 2844756., 2861424., 2816064., 2832768.,
      2849472., 2866176., 3692816., 3714944., 3737072., 3759200., 3698912.,
      3721088., 3743264., 3765440., 3705008., 3727232., 3749456., 3771680.,
      3711104., 3733376., 3755648., 3777920., 3717200., 3739520., 3761840.,
      3784160., 3723296., 3745664., 3768032., 3790400., 3729392., 3751808.,
      3774224., 3796640., 3735488., 3757952., 3780416., 3802880., 2753748.,
      2770488., 2787228., 2803968., 2758248., 2775024., 2791800., 2808576.,
      2762748., 2779560., 2796372., 2813184., 2767248., 2784096., 2800944.,
      2817792., 2771748., 2788632., 2805516., 2822400., 2776248., 2793168.,
      2810088., 2827008., 2780748., 2797704., 2814660., 2831616., 2785248.,
      2802240., 2819232., 2836224., 3371265., 3392010., 3412755., 3433500.,
      3376710., 3397500., 3418290., 3439080., 3382155., 3402990., 3423825.,
      3444660., 3387600., 3408480., 3429360., 3450240., 4440820., 4468480.,
      4496140., 4523800., 4447960., 4475680., 4503400., 4531120., 4455100.,
      4482880., 4510660., 4538440., 4462240., 4490080., 4517920., 4545760.,
      4469380., 4497280., 4525180., 4553080., 4476520., 4504480., 4532440.,
      4560400., 4483660., 4511680., 4539700., 4567720., 4490800., 4518880.,
      4546960., 4575040., 3309345., 3330270., 3351195., 3372120., 3314610.,
      3335580., 3356550., 3377520., 3319875., 3340890., 3361905., 3382920.,
      3325140., 3346200., 3367260., 3388320., 3330405., 3351510., 3372615.,
      3393720., 3335670., 3356820., 3377970., 3399120., 3340935., 3362130.,
      3383325., 3404520., 3346200., 3367440., 3388680., 3409920., 3545505.,
      3567690., 3589875., 3612060., 3550950., 3573180., 3595410., 3617640.,
      3556395., 3578670., 3600945., 3623220., 3561840., 3584160., 3606480.,
      3628800., 4669300., 4698880., 4728460., 4758040., 4676440., 4706080.,
      4735720., 4765360., 4683580., 4713280., 4742980., 4772680., 4690720.,
      4720480., 4750240., 4780000., 4697860., 4727680., 4757500., 4787320.,
      4705000., 4734880., 4764760., 4794640., 4712140., 4742080., 4772020.,
      4801960., 4719280., 4749280., 4779280., 4809280., 3477825., 3500190.,
      3522555., 3544920., 3483090., 3505500., 3527910., 3550320., 3488355.,
      3510810., 3533265., 3555720., 3493620., 3516120., 3538620., 3561120.,
      3498885., 3521430., 3543975., 3566520., 3504150., 3526740., 3549330.,
      3571920., 3509415., 3532050., 3554685., 3577320., 3514680., 3537360.,
      3560040., 3582720., 2666772., 2684520., 2702268., 2720016., 2670840.,
      2688624., 2706408., 2724192., 2674908., 2692728., 2710548., 2728368.,
      2678976., 2696832., 2714688., 2732544., 3509264., 3532928., 3556592.,
      3580256., 3514592., 3538304., 3562016., 3585728., 3519920., 3543680.,
      3567440., 3591200., 3525248., 3549056., 3572864., 3596672., 3530576.,
      3554432., 3578288., 3602144., 3535904., 3559808., 3583712., 3607616.,
      3541232., 3565184., 3589136., 3613088., 3546560., 3570560., 3594560.,
      3618560., 2611476., 2629368., 2647260., 2665152., 2615400., 2633328.,
      2651256., 2669184., 2619324., 2637288., 2655252., 2673216., 2623248.,
      2641248., 2659248., 2677248., 2627172., 2645208., 2663244., 2681280.,
      2631096., 2649168., 2667240., 2685312., 2635020., 2653128., 2671236.,
      2689344., 2638944., 2657088., 2675232., 2693376., 2796948., 2815848.,
      2834748., 2853648., 2801016., 2819952., 2838888., 2857824., 2805084.,
      2824056., 2843028., 2862000., 2809152., 2828160., 2847168., 2866176.,
      3679760., 3704960., 3730160., 3755360., 3685088., 3710336., 3735584.,
      3760832., 3690416., 3715712., 3741008., 3766304., 3695744., 3721088.,
      3746432., 3771776., 3701072., 3726464., 3751856., 3777248., 3706400.,
      3731840., 3757280., 3782720., 3711728., 3737216., 3762704., 3788192.,
      3717056., 3742592., 3768128., 3793664., 2737044., 2756088., 2775132.,
      2794176., 2740968., 2760048., 2779128., 2798208., 2744892., 2764008.,
      2783124., 2802240., 2748816., 2767968., 2787120., 2806272., 2752740.,
      2771928., 2791116., 2810304., 2756664., 2775888., 2795112., 2814336.,
      2760588., 2779848., 2799108., 2818368., 2764512., 2783808., 2803104.,
      2822400.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      343518., 350520., 357522., 364524., 344148., 351168., 358188., 365208.,
      344778., 351816., 358854., 365892., 345408., 352464., 359520., 366576.,
      346038., 353112., 360186., 367260., 346668., 353760., 360852., 367944.,
      347298., 354408., 361518., 368628., 347928., 355056., 362184., 369312.,
      348558., 355704., 362850., 369996., 349188., 356352., 363516., 370680.,
      349818., 357000., 364182., 371364., 350448., 357648., 364848., 372048.,
      351078., 358296., 365514., 372732., 351708., 358944., 366180., 373416.,
      352338., 359592., 366846., 374100., 352968., 360240., 367512., 374784.,
      353598., 360888., 368178., 375468., 354228., 361536., 368844., 376152.,
      354858., 362184., 369510., 376836., 355488., 362832., 370176., 377520.,
      363678., 371256., 378834., 386412., 364308., 371904., 379500., 387096.,
      364938., 372552., 380166., 387780., 365568., 373200., 380832., 388464.,
      366198., 373848., 381498., 389148., 366828., 374496., 382164., 389832.,
      367458., 375144., 382830., 390516., 368088., 375792., 383496., 391200.,
      368718., 376440., 384162., 391884., 369348., 377088., 384828., 392568.,
      369978., 377736., 385494., 393252., 370608., 378384., 386160., 393936.,
      371238., 379032., 386826., 394620., 371868., 379680., 387492., 395304.,
      372498., 380328., 388158., 395988., 373128., 380976., 388824., 396672.,
      373758., 381624., 389490., 397356., 374388., 382272., 390156., 398040.,
      375018., 382920., 390822., 398724., 375648., 383568., 391488., 399408.,
      383838., 391992., 400146., 408300., 384468., 392640., 400812., 408984.,
      385098., 393288., 401478., 409668., 385728., 393936., 402144., 410352.,
      386358., 394584., 402810., 411036., 386988., 395232., 403476., 411720.,
      387618., 395880., 404142., 412404., 388248., 396528., 404808., 413088.,
      388878., 397176., 405474., 413772., 389508., 397824., 406140., 414456.,
      390138., 398472., 406806., 415140., 390768., 399120., 407472., 415824.,
      391398., 399768., 408138., 416508., 392028., 400416., 408804., 417192.,
      392658., 401064., 409470., 417876., 393288., 401712., 410136., 418560.,
      393918., 402360., 410802., 419244., 394548., 403008., 411468., 419928.,
      395178., 403656., 412134., 420612., 395808., 404304., 412800., 421296.,
      403998., 412728., 421458., 430188., 404628., 413376., 422124., 430872.,
      405258., 414024., 422790., 431556., 405888., 414672., 423456., 432240.,
      406518., 415320., 424122., 432924., 407148., 415968., 424788., 433608.,
      407778., 416616., 425454., 434292., 408408., 417264., 426120., 434976.,
      409038., 417912., 426786., 435660., 409668., 418560., 427452., 436344.,
      410298., 419208., 428118., 437028., 410928., 419856., 428784., 437712.,
      411558., 420504., 429450., 438396., 412188., 421152., 430116., 439080.,
      412818., 421800., 430782., 439764., 413448., 422448., 431448., 440448.,
      414078., 423096., 432114., 441132., 414708., 423744., 432780., 441816.,
      415338., 424392., 433446., 442500., 415968., 425040., 434112., 443184.,
      424158., 433464., 442770., 452076., 424788., 434112., 443436., 452760.,
      425418., 434760., 444102., 453444., 426048., 435408., 444768., 454128.,
      426678., 436056., 445434., 454812., 427308., 436704., 446100., 455496.,
      427938., 437352., 446766., 456180., 428568., 438000., 447432., 456864.,
      429198., 438648., 448098., 457548., 429828., 439296., 448764., 458232.,
      430458., 439944., 449430., 458916., 431088., 440592., 450096., 459600.,
      431718., 441240., 450762., 460284., 432348., 441888., 451428., 460968.,
      432978., 442536., 452094., 461652., 433608., 443184., 452760., 462336.,
      434238., 443832., 453426., 463020., 434868., 444480., 454092., 463704.,
      435498., 445128., 454758., 464388., 436128., 445776., 455424., 465072.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      371480., 460090., 462520., 366440., 368360., 447100., 553550.,
      556400., 440650., 442900., 470200., 582050., 584900., 463150.,
      465400., 353960., 437890., 440020., 348200., 349880., 371240.,
      459190., 461320., 365000., 366680.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63810., 64188., 64566., 64944., 65322., 67590., 67968., 68346., 68724.,
      69102., 71370., 71748., 72126., 72504., 72882., 75150., 75528., 75906.,
      76284., 76662., 78930., 79308., 79686., 80064., 80442.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      736000.,  742960.,  911480.,  920180.,  916280.,  925040.,  725872.,
      732880.,  729664.,  736720.,  885500.,  894200.,  1096225., 1107100.,
      1101850., 1112800., 872540.,  881300.,  876980.,  885800.,  931100.,
      940400.,  1152475., 1164100., 1158100., 1169800., 916940.,  926300.,
      921380.,  930800.,  700480.,  707920.,  866480.,  875780.,  870680.,
      880040.,  688912.,  696400.,  692224.,  699760.,  734560.,  742480.,
      908480.,  918380.,  912680.,  922640.,  722032.,  730000.,  725344.,
      733360.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      124299., 127620., 125028., 128376., 125757., 129132., 126486., 129888.,
      127215., 130644., 131589., 135180., 132318., 135936., 133047., 136692.,
      133776., 137448., 134505., 138204., 138879., 142740., 139608., 143496.,
      140337., 144252., 141066., 145008., 141795., 145764., 146169., 150300.,
      146898., 151056., 147627., 151812., 148356., 152568., 149085., 153324.,
      153459., 157860., 154188., 158616., 154917., 159372., 155646., 160128.,
      156375., 160884.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1465040., 1472000., 1478960., 1485920., 1814260., 1822960., 1831660.,
      1840360., 1823800., 1832560., 1841320., 1850080., 1444736., 1451744.,
      1458752., 1465760., 1452272., 1459328., 1466384., 1473440., 1762300.,
      1771000., 1779700., 1788400., 2181575., 2192450., 2203325., 2214200.,
      2192750., 2203700., 2214650., 2225600., 1736320., 1745080., 1753840.,
      1762600., 1745140., 1753960., 1762780., 1771600., 1852900., 1862200.,
      1871500., 1880800., 2293325., 2304950., 2316575., 2328200., 2304500.,
      2316200., 2327900., 2339600., 1824520., 1833880., 1843240., 1852600.,
      1833340., 1842760., 1852180., 1861600., 1393520., 1400960., 1408400.,
      1415840., 1723660., 1732960., 1742260., 1751560., 1732000., 1741360.,
      1750720., 1760080., 1370336., 1377824., 1385312., 1392800., 1376912.,
      1384448., 1391984., 1399520., 1461200., 1469120., 1477040., 1484960.,
      1807060., 1816960., 1826860., 1836760., 1815400., 1825360., 1835320.,
      1845280., 1436096., 1444064., 1452032., 1460000., 1442672., 1450688.,
      1458704., 1466720.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      245277., 248598., 251919., 255240., 246708., 250056., 253404., 256752.,
      248139., 251514., 254889., 258264., 249570., 252972., 256374., 259776.,
      251001., 254430., 257859., 261288., 259587., 263178., 266769., 270360.,
      261018., 264636., 268254., 271872., 262449., 266094., 269739., 273384.,
      263880., 267552., 271224., 274896., 265311., 269010., 272709., 276408.,
      273897., 277758., 281619., 285480., 275328., 279216., 283104., 286992.,
      276759., 280674., 284589., 288504., 278190., 282132., 286074., 290016.,
      279621., 283590., 287559., 291528., 288207., 292338., 296469., 300600.,
      289638., 293796., 297954., 302112., 291069., 295254., 299439., 303624.,
      292500., 296712., 300924., 305136., 293931., 298170., 302409., 306648.,
      302517., 306918., 311319., 315720., 303948., 308376., 312804., 317232.,
      305379., 309834., 314289., 318744., 306810., 311292., 315774., 320256.,
      308241., 312750., 317259., 321768.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      740992.,  742960.,  917750.,  920180.,  922610.,  925040.,  730960.,
      732880.,  734800.,  736720.,  891890.,  894200.,  1104250., 1107100.,
      1109950., 1112800., 879050.,  881300.,  883550.,  885800.,  938090.,
      940400.,  1161250., 1164100., 1166950., 1169800., 924050.,  926300.,
      928550.,  930800.,  706192.,  707920.,  873650.,  875780.,  877910.,
      880040.,  694720.,  696400.,  698080.,  699760.,  740752.,  742480.,
      916250.,  918380.,  920510.,  922640.,  728320.,  730000.,  731680.,
      733360.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      127242., 127620., 127998., 128376., 128754., 129132., 129510., 129888.,
      130266., 130644., 134802., 135180., 135558., 135936., 136314., 136692.,
      137070., 137448., 137826., 138204., 142362., 142740., 143118., 143496.,
      143874., 144252., 144630., 145008., 145386., 145764., 149922., 150300.,
      150678., 151056., 151434., 151812., 152190., 152568., 152946., 153324.,
      157482., 157860., 158238., 158616., 158994., 159372., 159750., 160128.,
      160506., 160884.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1468112., 1481984., 1472000., 1485920., 1818160., 1835500., 1822960.,
      1840360., 1827760., 1845220., 1832560., 1850080., 1447952., 1461920.,
      1451744., 1465760., 1455536., 1469600., 1459328., 1473440., 1766440.,
      1783780., 1771000., 1788400., 2186825., 2208500., 2192450., 2214200.,
      2198075., 2219900., 2203700., 2225600., 1740640., 1758100., 1745080.,
      1762600., 1749520., 1767100., 1753960., 1771600., 1857640., 1876180.,
      1862200., 1880800., 2299325., 2322500., 2304950., 2328200., 2310575.,
      2333900., 2316200., 2339600., 1829440., 1848100., 1833880., 1852600.,
      1838320., 1857100., 1842760., 1861600., 1397552., 1412384., 1400960.,
      1415840., 1728760., 1747300., 1732960., 1751560., 1737160., 1755820.,
      1741360., 1760080., 1374512., 1389440., 1377824., 1392800., 1381136.,
      1396160., 1384448., 1399520., 1465712., 1481504., 1469120., 1484960.,
      1812760., 1832500., 1816960., 1836760., 1821160., 1841020., 1825360.,
      1845280., 1440752., 1456640., 1444064., 1460000., 1447376., 1463360.,
      1450688., 1466720.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      247869., 254484., 248598., 255240., 249327., 255996., 250056., 256752.,
      250785., 257508., 251514., 258264., 252243., 259020., 252972., 259776.,
      253701., 260532., 254430., 261288., 262449., 269604., 263178., 270360.,
      263907., 271116., 264636., 271872., 265365., 272628., 266094., 273384.,
      266823., 274140., 267552., 274896., 268281., 275652., 269010., 276408.,
      277029., 284724., 277758., 285480., 278487., 286236., 279216., 286992.,
      279945., 287748., 280674., 288504., 281403., 289260., 282132., 290016.,
      282861., 290772., 283590., 291528., 291609., 299844., 292338., 300600.,
      293067., 301356., 293796., 302112., 294525., 302868., 295254., 303624.,
      295983., 304380., 296712., 305136., 297441., 305892., 298170., 306648.,
      306189., 314964., 306918., 315720., 307647., 316476., 308376., 317232.,
      309105., 317988., 309834., 318744., 310563., 319500., 311292., 320256.,
      312021., 321012., 312750., 321768.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2922352., 2936224., 2950096., 2963968., 2930080., 2944000., 2957920.,
      2971840., 3618980., 3636320., 3653660., 3671000., 3628520., 3645920.,
      3663320., 3680720., 3638060., 3655520., 3672980., 3690440., 3647600.,
      3665120., 3682640., 3700160., 2881936., 2895904., 2909872., 2923840.,
      2889472., 2903488., 2917504., 2931520., 2897008., 2911072., 2925136.,
      2939200., 2904544., 2918656., 2932768., 2946880., 3515540., 3532880.,
      3550220., 3567560., 3524600., 3542000., 3559400., 3576800., 4351975.,
      4373650., 4395325., 4417000., 4363150., 4384900., 4406650., 4428400.,
      4374325., 4396150., 4417975., 4439800., 4385500., 4407400., 4429300.,
      4451200., 3463820., 3481280., 3498740., 3516200., 3472640., 3490160.,
      3507680., 3525200., 3481460., 3499040., 3516620., 3534200., 3490280.,
      3507920., 3525560., 3543200., 3696740., 3715280., 3733820., 3752360.,
      3705800., 3724400., 3743000., 3761600., 4575475., 4598650., 4621825.,
      4645000., 4586650., 4609900., 4633150., 4656400., 4597825., 4621150.,
      4644475., 4667800., 4609000., 4632400., 4655800., 4679200., 3640220.,
      3658880., 3677540., 3696200., 3649040., 3667760., 3686480., 3705200.,
      3657860., 3676640., 3695420., 3714200., 3666680., 3685520., 3704360.,
      3723200., 2780272., 2795104., 2809936., 2824768., 2787040., 2801920.,
      2816800., 2831680., 3438980., 3457520., 3476060., 3494600., 3447320.,
      3465920., 3484520., 3503120., 3455660., 3474320., 3492980., 3511640.,
      3464000., 3482720., 3501440., 3520160., 2734096., 2749024., 2763952.,
      2778880., 2740672., 2755648., 2770624., 2785600., 2747248., 2762272.,
      2777296., 2792320., 2753824., 2768896., 2783968., 2799040., 2915632.,
      2931424., 2947216., 2963008., 2922400., 2938240., 2954080., 2969920.,
      3605780., 3625520., 3645260., 3665000., 3614120., 3633920., 3653720.,
      3673520., 3622460., 3642320., 3662180., 3682040., 3630800., 3650720.,
      3670640., 3690560., 2865616., 2881504., 2897392., 2913280., 2872192.,
      2888128., 2904064., 2920000., 2878768., 2894752., 2910736., 2926720.,
      2885344., 2901376., 2917408., 2933440.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      489123., 495738., 502353., 508968., 490554., 497196., 503838., 510480.,
      491985., 498654., 505323., 511992., 493416., 500112., 506808., 513504.,
      494847., 501570., 508293., 515016., 496278., 503028., 509778., 516528.,
      497709., 504486., 511263., 518040., 499140., 505944., 512748., 519552.,
      500571., 507402., 514233., 521064., 502002., 508860., 515718., 522576.,
      517743., 524898., 532053., 539208., 519174., 526356., 533538., 540720.,
      520605., 527814., 535023., 542232., 522036., 529272., 536508., 543744.,
      523467., 530730., 537993., 545256., 524898., 532188., 539478., 546768.,
      526329., 533646., 540963., 548280., 527760., 535104., 542448., 549792.,
      529191., 536562., 543933., 551304., 530622., 538020., 545418., 552816.,
      546363., 554058., 561753., 569448., 547794., 555516., 563238., 570960.,
      549225., 556974., 564723., 572472., 550656., 558432., 566208., 573984.,
      552087., 559890., 567693., 575496., 553518., 561348., 569178., 577008.,
      554949., 562806., 570663., 578520., 556380., 564264., 572148., 580032.,
      557811., 565722., 573633., 581544., 559242., 567180., 575118., 583056.,
      574983., 583218., 591453., 599688., 576414., 584676., 592938., 601200.,
      577845., 586134., 594423., 602712., 579276., 587592., 595908., 604224.,
      580707., 589050., 597393., 605736., 582138., 590508., 598878., 607248.,
      583569., 591966., 600363., 608760., 585000., 593424., 601848., 610272.,
      586431., 594882., 603333., 611784., 587862., 596340., 604818., 613296.,
      603603., 612378., 621153., 629928., 605034., 613836., 622638., 631440.,
      606465., 615294., 624123., 632952., 607896., 616752., 625608., 634464.,
      609327., 618210., 627093., 635976., 610758., 619668., 628578., 637488.,
      612189., 621126., 630063., 639000., 613620., 622584., 631548., 640512.,
      615051., 624042., 633033., 642024., 616482., 625500., 634518., 643536.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1480016., 1481984., 1483952., 1485920., 1833070., 1835500., 1837930.,
      1840360., 1842790., 1845220., 1847650., 1850080., 1460000., 1461920.,
      1463840., 1465760., 1467680., 1469600., 1471520., 1473440., 1781470.,
      1783780., 1786090., 1788400., 2205650., 2208500., 2211350., 2214200.,
      2217050., 2219900., 2222750., 2225600., 1755850., 1758100., 1760350.,
      1762600., 1764850., 1767100., 1769350., 1771600., 1873870., 1876180.,
      1878490., 1880800., 2319650., 2322500., 2325350., 2328200., 2331050.,
      2333900., 2336750., 2339600., 1845850., 1848100., 1850350., 1852600.,
      1854850., 1857100., 1859350., 1861600., 1410656., 1412384., 1414112.,
      1415840., 1745170., 1747300., 1749430., 1751560., 1753690., 1755820.,
      1757950., 1760080., 1387760., 1389440., 1391120., 1392800., 1394480.,
      1396160., 1397840., 1399520., 1479776., 1481504., 1483232., 1484960.,
      1830370., 1832500., 1834630., 1836760., 1838890., 1841020., 1843150.,
      1845280., 1454960., 1456640., 1458320., 1460000., 1461680., 1463360.,
      1465040., 1466720.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      254106., 254484., 254862., 255240., 255618., 255996., 256374., 256752.,
      257130., 257508., 257886., 258264., 258642., 259020., 259398., 259776.,
      260154., 260532., 260910., 261288., 269226., 269604., 269982., 270360.,
      270738., 271116., 271494., 271872., 272250., 272628., 273006., 273384.,
      273762., 274140., 274518., 274896., 275274., 275652., 276030., 276408.,
      284346., 284724., 285102., 285480., 285858., 286236., 286614., 286992.,
      287370., 287748., 288126., 288504., 288882., 289260., 289638., 290016.,
      290394., 290772., 291150., 291528., 299466., 299844., 300222., 300600.,
      300978., 301356., 301734., 302112., 302490., 302868., 303246., 303624.,
      304002., 304380., 304758., 305136., 305514., 305892., 306270., 306648.,
      314586., 314964., 315342., 315720., 316098., 316476., 316854., 317232.,
      317610., 317988., 318366., 318744., 319122., 319500., 319878., 320256.,
      320634., 321012., 321390., 321768.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2932336., 2960032., 2936224., 2963968., 2940112., 2967904., 2944000.,
      2971840., 3631520., 3666140., 3636320., 3671000., 3641120., 3675860.,
      3645920., 3680720., 3650720., 3685580., 3655520., 3690440., 3660320.,
      3695300., 3665120., 3700160., 2892112., 2920000., 2895904., 2923840.,
      2899696., 2927680., 2903488., 2931520., 2907280., 2935360., 2911072.,
      2939200., 2914864., 2943040., 2918656., 2946880., 3528320., 3562940.,
      3532880., 3567560., 3537440., 3572180., 3542000., 3576800., 4368025.,
      4411300., 4373650., 4417000., 4379275., 4422700., 4384900., 4428400.,
      4390525., 4434100., 4396150., 4439800., 4401775., 4445500., 4407400.,
      4451200., 3476840., 3511700., 3481280., 3516200., 3485720., 3520700.,
      3490160., 3525200., 3494600., 3529700., 3499040., 3534200., 3503480.,
      3538700., 3507920., 3543200., 3710720., 3747740., 3715280., 3752360.,
      3719840., 3756980., 3724400., 3761600., 4593025., 4639300., 4598650.,
      4645000., 4604275., 4650700., 4609900., 4656400., 4615525., 4662100.,
      4621150., 4667800., 4626775., 4673500., 4632400., 4679200., 3654440.,
      3691700., 3658880., 3696200., 3663320., 3700700., 3667760., 3705200.,
      3672200., 3709700., 3676640., 3714200., 3681080., 3718700., 3685520.,
      3723200., 2791696., 2821312., 2795104., 2824768., 2798512., 2828224.,
      2801920., 2831680., 3453320., 3490340., 3457520., 3494600., 3461720.,
      3498860., 3465920., 3503120., 3470120., 3507380., 3474320., 3511640.,
      3478520., 3515900., 3482720., 3520160., 2745712., 2775520., 2749024.,
      2778880., 2752336., 2782240., 2755648., 2785600., 2758960., 2788960.,
      2762272., 2792320., 2765584., 2795680., 2768896., 2799040., 2928016.,
      2959552., 2931424., 2963008., 2934832., 2966464., 2938240., 2969920.,
      3621320., 3660740., 3625520., 3665000., 3629720., 3669260., 3633920.,
      3673520., 3638120., 3677780., 3642320., 3682040., 3646520., 3686300.,
      3650720., 3690560., 2878192., 2909920., 2881504., 2913280., 2884816.,
      2916640., 2888128., 2920000., 2891440., 2923360., 2894752., 2926720.,
      2898064., 2930080., 2901376., 2933440.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      495009., 508212., 495738., 508968., 496467., 509724., 497196., 510480.,
      497925., 511236., 498654., 511992., 499383., 512748., 500112., 513504.,
      500841., 514260., 501570., 515016., 502299., 515772., 503028., 516528.,
      503757., 517284., 504486., 518040., 505215., 518796., 505944., 519552.,
      506673., 520308., 507402., 521064., 508131., 521820., 508860., 522576.,
      524169., 538452., 524898., 539208., 525627., 539964., 526356., 540720.,
      527085., 541476., 527814., 542232., 528543., 542988., 529272., 543744.,
      530001., 544500., 530730., 545256., 531459., 546012., 532188., 546768.,
      532917., 547524., 533646., 548280., 534375., 549036., 535104., 549792.,
      535833., 550548., 536562., 551304., 537291., 552060., 538020., 552816.,
      553329., 568692., 554058., 569448., 554787., 570204., 555516., 570960.,
      556245., 571716., 556974., 572472., 557703., 573228., 558432., 573984.,
      559161., 574740., 559890., 575496., 560619., 576252., 561348., 577008.,
      562077., 577764., 562806., 578520., 563535., 579276., 564264., 580032.,
      564993., 580788., 565722., 581544., 566451., 582300., 567180., 583056.,
      582489., 598932., 583218., 599688., 583947., 600444., 584676., 601200.,
      585405., 601956., 586134., 602712., 586863., 603468., 587592., 604224.,
      588321., 604980., 589050., 605736., 589779., 606492., 590508., 607248.,
      591237., 608004., 591966., 608760., 592695., 609516., 593424., 610272.,
      594153., 611028., 594882., 611784., 595611., 612540., 596340., 613296.,
      611649., 629172., 612378., 629928., 613107., 630684., 613836., 631440.,
      614565., 632196., 615294., 632952., 616023., 633708., 616752., 634464.,
      617481., 635220., 618210., 635976., 618939., 636732., 619668., 637488.,
      620397., 638244., 621126., 639000., 621855., 639756., 622584., 640512.,
      623313., 641268., 624042., 642024., 624771., 642780., 625500., 643536.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, SAME3x10x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5836976., 5864672., 5892368., 5920064., 5844704., 5872448., 5900192.,
      5927936., 5852432., 5880224., 5908016., 5935808., 5860160., 5888000.,
      5915840., 5943680., 7228420., 7263040., 7297660., 7332280., 7237960.,
      7272640., 7307320., 7342000., 7247500., 7282240., 7316980., 7351720.,
      7257040., 7291840., 7326640., 7361440., 7266580., 7301440., 7336300.,
      7371160., 7276120., 7311040., 7345960., 7380880., 7285660., 7320640.,
      7355620., 7390600., 7295200., 7330240., 7365280., 7400320., 5756336.,
      5784224., 5812112., 5840000., 5763872., 5791808., 5819744., 5847680.,
      5771408., 5799392., 5827376., 5855360., 5778944., 5806976., 5835008.,
      5863040., 5786480., 5814560., 5842640., 5870720., 5794016., 5822144.,
      5850272., 5878400., 5801552., 5829728., 5857904., 5886080., 5809088.,
      5837312., 5865536., 5893760., 7022020., 7056640., 7091260., 7125880.,
      7031080., 7065760., 7100440., 7135120., 7040140., 7074880., 7109620.,
      7144360., 7049200., 7084000., 7118800., 7153600., 8692775., 8736050.,
      8779325., 8822600., 8703950., 8747300., 8790650., 8834000., 8715125.,
      8758550., 8801975., 8845400., 8726300., 8769800., 8813300., 8856800.,
      8737475., 8781050., 8824625., 8868200., 8748650., 8792300., 8835950.,
      8879600., 8759825., 8803550., 8847275., 8891000., 8771000., 8814800.,
      8858600., 8902400., 6918820., 6953680., 6988540., 7023400., 6927640.,
      6962560., 6997480., 7032400., 6936460., 6971440., 7006420., 7041400.,
      6945280., 6980320., 7015360., 7050400., 6954100., 6989200., 7024300.,
      7059400., 6962920., 6998080., 7033240., 7068400., 6971740., 7006960.,
      7042180., 7077400., 6980560., 7015840., 7051120., 7086400., 7384420.,
      7421440., 7458460., 7495480., 7393480., 7430560., 7467640., 7504720.,
      7402540., 7439680., 7476820., 7513960., 7411600., 7448800., 7486000.,
      7523200., 9139775., 9186050., 9232325., 9278600., 9150950., 9197300.,
      9243650., 9290000., 9162125., 9208550., 9254975., 9301400., 9173300.,
      9219800., 9266300., 9312800., 9184475., 9231050., 9277625., 9324200.,
      9195650., 9242300., 9288950., 9335600., 9206825., 9253550., 9300275.,
      9347000., 9218000., 9264800., 9311600., 9358400., 7271620., 7308880.,
      7346140., 7383400., 7280440., 7317760., 7355080., 7392400., 7289260.,
      7326640., 7364020., 7401400., 7298080., 7335520., 7372960., 7410400.,
      7306900., 7344400., 7381900., 7419400., 7315720., 7353280., 7390840.,
      7428400., 7324540., 7362160., 7399780., 7437400., 7333360., 7371040.,
      7408720., 7446400., 5553776., 5583392., 5613008., 5642624., 5560544.,
      5590208., 5619872., 5649536., 5567312., 5597024., 5626736., 5656448.,
      5574080., 5603840., 5633600., 5663360., 6869620., 6906640., 6943660.,
      6980680., 6877960., 6915040., 6952120., 6989200., 6886300., 6923440.,
      6960580., 6997720., 6894640., 6931840., 6969040., 7006240., 6902980.,
      6940240., 6977500., 7014760., 6911320., 6948640., 6985960., 7023280.,
      6919660., 6957040., 6994420., 7031800., 6928000., 6965440., 7002880.,
      7040320., 5461616., 5491424., 5521232., 5551040., 5468192., 5498048.,
      5527904., 5557760., 5474768., 5504672., 5534576., 5564480., 5481344.,
      5511296., 5541248., 5571200., 5487920., 5517920., 5547920., 5577920.,
      5494496., 5524544., 5554592., 5584640., 5501072., 5531168., 5561264.,
      5591360., 5507648., 5537792., 5567936., 5598080., 5824496., 5856032.,
      5887568., 5919104., 5831264., 5862848., 5894432., 5926016., 5838032.,
      5869664., 5901296., 5932928., 5844800., 5876480., 5908160., 5939840.,
      7203220., 7242640., 7282060., 7321480., 7211560., 7251040., 7290520.,
      7330000., 7219900., 7259440., 7298980., 7338520., 7228240., 7267840.,
      7307440., 7347040., 7236580., 7276240., 7315900., 7355560., 7244920.,
      7284640., 7324360., 7364080., 7253260., 7293040., 7332820., 7372600.,
      7261600., 7301440., 7341280., 7381120., 5724656., 5756384., 5788112.,
      5819840., 5731232., 5763008., 5794784., 5826560., 5737808., 5769632.,
      5801456., 5833280., 5744384., 5776256., 5808128., 5840000., 5750960.,
      5782880., 5814800., 5846720., 5757536., 5789504., 5821472., 5853440.,
      5764112., 5796128., 5828144., 5860160., 5770688., 5802752., 5834816.,
      5866880.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride2, VALID3x10x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      976815.,  990018.,  1003221., 1016424., 978246.,  991476.,  1004706.,
      1017936., 979677.,  992934.,  1006191., 1019448., 981108.,  994392.,
      1007676., 1020960., 982539.,  995850.,  1009161., 1022472., 983970.,
      997308.,  1010646., 1023984., 985401.,  998766.,  1012131., 1025496.,
      986832.,  1000224., 1013616., 1027008., 988263.,  1001682., 1015101.,
      1028520., 989694.,  1003140., 1016586., 1030032., 991125.,  1004598.,
      1018071., 1031544., 992556.,  1006056., 1019556., 1033056., 993987.,
      1007514., 1021041., 1034568., 995418.,  1008972., 1022526., 1036080.,
      996849.,  1010430., 1024011., 1037592., 998280.,  1011888., 1025496.,
      1039104., 999711.,  1013346., 1026981., 1040616., 1001142., 1014804.,
      1028466., 1042128., 1002573., 1016262., 1029951., 1043640., 1004004.,
      1017720., 1031436., 1045152., 1034055., 1048338., 1062621., 1076904.,
      1035486., 1049796., 1064106., 1078416., 1036917., 1051254., 1065591.,
      1079928., 1038348., 1052712., 1067076., 1081440., 1039779., 1054170.,
      1068561., 1082952., 1041210., 1055628., 1070046., 1084464., 1042641.,
      1057086., 1071531., 1085976., 1044072., 1058544., 1073016., 1087488.,
      1045503., 1060002., 1074501., 1089000., 1046934., 1061460., 1075986.,
      1090512., 1048365., 1062918., 1077471., 1092024., 1049796., 1064376.,
      1078956., 1093536., 1051227., 1065834., 1080441., 1095048., 1052658.,
      1067292., 1081926., 1096560., 1054089., 1068750., 1083411., 1098072.,
      1055520., 1070208., 1084896., 1099584., 1056951., 1071666., 1086381.,
      1101096., 1058382., 1073124., 1087866., 1102608., 1059813., 1074582.,
      1089351., 1104120., 1061244., 1076040., 1090836., 1105632., 1091295.,
      1106658., 1122021., 1137384., 1092726., 1108116., 1123506., 1138896.,
      1094157., 1109574., 1124991., 1140408., 1095588., 1111032., 1126476.,
      1141920., 1097019., 1112490., 1127961., 1143432., 1098450., 1113948.,
      1129446., 1144944., 1099881., 1115406., 1130931., 1146456., 1101312.,
      1116864., 1132416., 1147968., 1102743., 1118322., 1133901., 1149480.,
      1104174., 1119780., 1135386., 1150992., 1105605., 1121238., 1136871.,
      1152504., 1107036., 1122696., 1138356., 1154016., 1108467., 1124154.,
      1139841., 1155528., 1109898., 1125612., 1141326., 1157040., 1111329.,
      1127070., 1142811., 1158552., 1112760., 1128528., 1144296., 1160064.,
      1114191., 1129986., 1145781., 1161576., 1115622., 1131444., 1147266.,
      1163088., 1117053., 1132902., 1148751., 1164600., 1118484., 1134360.,
      1150236., 1166112., 1148535., 1164978., 1181421., 1197864., 1149966.,
      1166436., 1182906., 1199376., 1151397., 1167894., 1184391., 1200888.,
      1152828., 1169352., 1185876., 1202400., 1154259., 1170810., 1187361.,
      1203912., 1155690., 1172268., 1188846., 1205424., 1157121., 1173726.,
      1190331., 1206936., 1158552., 1175184., 1191816., 1208448., 1159983.,
      1176642., 1193301., 1209960., 1161414., 1178100., 1194786., 1211472.,
      1162845., 1179558., 1196271., 1212984., 1164276., 1181016., 1197756.,
      1214496., 1165707., 1182474., 1199241., 1216008., 1167138., 1183932.,
      1200726., 1217520., 1168569., 1185390., 1202211., 1219032., 1170000.,
      1186848., 1203696., 1220544., 1171431., 1188306., 1205181., 1222056.,
      1172862., 1189764., 1206666., 1223568., 1174293., 1191222., 1208151.,
      1225080., 1175724., 1192680., 1209636., 1226592., 1205775., 1223298.,
      1240821., 1258344., 1207206., 1224756., 1242306., 1259856., 1208637.,
      1226214., 1243791., 1261368., 1210068., 1227672., 1245276., 1262880.,
      1211499., 1229130., 1246761., 1264392., 1212930., 1230588., 1248246.,
      1265904., 1214361., 1232046., 1249731., 1267416., 1215792., 1233504.,
      1251216., 1268928., 1217223., 1234962., 1252701., 1270440., 1218654.,
      1236420., 1254186., 1271952., 1220085., 1237878., 1255671., 1273464.,
      1221516., 1239336., 1257156., 1274976., 1222947., 1240794., 1258641.,
      1276488., 1224378., 1242252., 1260126., 1278000., 1225809., 1243710.,
      1261611., 1279512., 1227240., 1245168., 1263096., 1281024., 1228671.,
      1246626., 1264581., 1282536., 1230102., 1248084., 1266066., 1284048.,
      1231533., 1249542., 1267551., 1285560., 1232964., 1251000., 1269036.,
      1287072.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}